Java 2015 2016_zied_elleuch

P.O.O. : JavaP.O.O. : Java
Zied ELLEUCH

Plan
Présentation du langage java
Concept Object
Les bases du langage java
Classes et objets java
Héritage, polymorphisme et interfaces
2
Les exceptions
Les entrées/sorties

Le langage Java est un langage orienté objet développé en 1990
chez SUN MicroSystems sous la direction de Bill Joy et James
Gosling (depuis 2009, cette société appartient à Oracle
Corporation). L'objectif de Java était de fournir un langage orienté
objet capable de fonctionner sur n'importe quelle plateforme
(Windows, Macintosh, Unix).
3
Le langage est appelé Java (café en argot américain).
En 1993, avec l'intérêt grandissant d'Internet, ce langage, se
métamorphose en langage dédié à Internet : SUN diffuse le premier
browser HotJava qui permet d'exécuter des programmes Java
encapsulés dans des pages WEB (i.e. des applets Java) de plus en
plus «vivantes ».
1996 : Les Java Développement Kits (JDK) sont disponibles
gratuitement pour la plupart des machines du marché.

Version Date de diffusion
JDK 1.0 Mai 1995
JDK 1.1 Février 1997
JDK 1.1.4 Septembre 1997
JDK 1.1.5 Décembre 1997
Version Date de diffusion
J2SE 1.2.2 Juillet 1999
J2SE 1.3 Mai 2000
J2SE 1.3.1 Mai 2001
J2SE 1.4.0 Février 2002
Les différentes versions de Java
4
JDK 1.1.5 Décembre 1997
JDK 1.1.6 Avril 1998
JDK 1.1.7 Septembre 1998
JDK 1.1.8 Avril 1999
J2SE 1.2 Décembre 1998
J2SE 1.2.1 Mars 1999
J2SE 1.4.0 Février 2002
J2SE 1.4.1 Septembre 2002
J2SE 1.4.2 Juin, 2003
J2SE 5.0 (1.5) Septembre 2004
Java SE 6.0 (1.6) Décembre 2006
Java SE 7.0 (1.7) Fin 2010
(JDK= Java Development Kit) (J2SE=Java 2 Standard Edition)

Langage très proche du C/C++ : Java se base sur la syntaxe du
C/C++ pour tout ce qui est déclaration de variables simples (int,
float, double, char, etc.) et tout ce qui est structures de contrôle
(if…else, etc.) et itératives (while, for, do…while, etc.).
Java est un langage simple par rapport au langage C et C++: Il n'y
5
Java est un langage simple par rapport au langage C et C++: Il n'y
a plus de pointeurs et des manipulations les concernant.
Java se charge (presque) de restituer au système les zones
mémoire inaccessibles et ce sans l'intervention du programmeur.

Langage presque complètement Objet :
−Tout est classe sauf les types primitifs qui ne sont pas des
classes (int, float, etc.).
−Il n'existe plus de fonctions à l'extérieur de la classe : même la
fonction main fait partie d'une classe. L'implémentation des
fonctions membres de fait aussi toujours à l'intérieur de la classe.
−Un fichier contient forcément une classe ou plusieurs classes.
6
−Un fichier contient forcément une classe ou plusieurs classes.
Paquetage pour la réutilisation :
−java.lang : classes de base
−java.io : entrée/sortie
−java.awt : interfaces graphiques
−java.net : communication réseaux(socket et URL)
−java.applet : API Applet
−java.util : classes outils

Le langage Java est distribué :
−Supporte des applications réseaux (protocoles de
communication java.net)
−URL : permet l ’accès à des objets distants
−RMI : Remote Method Invocation
−Programmation d'applications Client/Serveur : classe Socket
Manipulation de fichier local ou fichier distant identique :
7
Manipulation de fichier local ou fichier distant identique :
indifférence à la localisation

Un programme écrit en langage compilé est un programme qui est
converti en des instructions écrites en langage machine avant l'exécution.
Un programme écrit en langage interprété est un programme converti
en instructions écrites en langage machine au fur et à mesure de
l'exécution.
Java est considéré comme un langage compilé et interprété à la fois.
Langage compilé ou interprété?
8
Java est considéré comme un langage compilé et interprété à la fois.
Un programme écrit en java est tout d’abords compilé puis interprété.
Au début, s'il n'y a pas d'erreur, le compilateur java traduit le code
source du fichier Personne.java en un code objet appelé aussi Bytecode.
Le fichier généré est le fichier Personne.class. Ensuite, la Machine
Virtuelle Java JVM (en anglais = Java Virtual Machine) installée sur
l'ordinateur permet d'interpréter ce Bytecode en langage compris par la
machine.
Java est un langage portable, c'est-à-dire qui fonctionne sur n'importe
quel système d'exploitation et ce grâce à la JVM.

9
Bytecode = Pseudo code machine qui contrairement à du code binaire
natif, n'est pas exécuté directement par le processeur, ce qui à pour
conséquence de ralentir son exécution.

Java Virtual Machine (JVM)
10
La JVM est un programme qui réalise principalement les trois
tâches suivantes :
−lire les instructions en bytecode
−les traduire dans le langage natif du processeur de l’ordinateur
−lancer leurs exécution
Ce programme simule ( machine virtuelle ) le comportement d’une
vraie machine dont le langage natif est le bytecode.

Processus d’exécution
11

Langage simple
−La syntaxe de java est simple à lire
−Les pointeurs n'existent plus en java
−La libération d'espace inutilisé est faite avec le ramasse-miettes
(en anglais Garbage collector) : les objets non référencés sont
automatiquement supprimés de la mémoire dès que la mémoire
disponible devient inférieure à un seuil donné. Ce processus
12
disponible devient inférieure à un seuil donné. Ce processus
s'exécute en tâche de fond sans que l'utilisateur ne s'en aperçoive.
Langage multi-tâches
−Java est un langage qui permet d'exécuter plusieurs processus en
même temps (en anglais multithread). Par exemple, lancer deux
comptes à rebours décalés de deux secondes.
−Exécuter le garbage collector en même temps qu'un processus
lancé par l'utilisateur

Installation de java
Plusieurs versions de Java ont été proposées depuis 1995. Au
début, le Kit à installer s'appelait JDK (Java Development Kit).
Puis depuis la version 1.2, il a été baptisé J2SE (Java 2 Standard
Edition). Lors de l'installation d'un de ces Kits, le programme
installe un compilateur java et la JVM. Néanmoins, un
utilisateur peut installer seulement la JVM sur une machine s'il a
13
utilisateur peut installer seulement la JVM sur une machine s'il a
juste besoin d'exécuter un programme java. Pour cela, il doit
installer le JRE approprié et compatible avec son système
d'exploitation (JRE : Java Runtime Environment) .
Lorsqu'une version de java est installée, l'utilisateur peut utiliser
n'importe quel éditeur de texte pour écrire son code java puis
compiler le programme et l'exécuter en mode commande.

Installation de java
Le Java Development Kit(JDK) comprends :
−Toutes les classes du java (J2SE)
−Un compilateur (javac.exe)
−Une machine virtuelle (java.exe)
−Un debuggeur (jdb.exe)
−Un générateur de documentation technique (javadoc.exe)
14
−Un générateur de documentation technique (javadoc.exe)
−Un générateur de fichiers archives ŔJAR (jar.exe)
−Une visionneuse d'applets (appletviewer.exe)
−Divers outils pour le RMI
−Etc.
Exemple
Compilation : >javac Personne.java
S'il n'y a pas d'erreurs, ceci permet de créer un fichier appelé Personne.class
Exécution : >java Personne

Pour faciliter la compilation et l'exécution, il existe différents
éditeurs appelés aussi (Environnement de développement intégré
(Integrated Development Environment (IDE)) qui sont proposés à
titre gratuit ou sous licence payante. Ex . NetBeans, Jcreator,
Eclipse (ces trois sont gratuits), Jbuilder (payant).
Documentation java
15
Documentation java
Une documentation contenant toutes les classes de java 6, leurs
méthodes et leurs attributs est disponible à l'adresse suivante :
http://docs.oracle.com/javase/6/docs/api/

package java;
public class HelloEPI {
public static void main(String[] args) {
System.out.println("Hello EPI");
}
}
16
Une application Java minimale doit contenir une classe.
Portant le même nom que le fichier ayant l’extension « .java » dans
le quel elle est enregistré.
Comportant ( au moins) une méthode appelée main, de type public
et static et ayant un argument de type String[ ]

package java;
}
Le mot class veut dire que nous allons définir une nouvelle classe
Java, suivi du nom de cette classe.
17
En Java, les majuscules et les minuscules sont considérés comme
des caractères différents : HelloEPI n’est pas identique à HelloEpi.
Les caractères « { et } » marquent le début et la fin du bloc
d’instructions a réaliser par la classe.

package java;
}
}
18
main(String[] args) : signifie que nous allons définir une méthode
appelée main.
Le mot main indique que cette méthode est la méthode principale de
la classe.
Un interpréteur Java à pour fonction d’exécuter les instructions
contenus dans le bloc d’instruction de la méthode principale main,
du programme qu’on lui soumet.
Une méthode est une sorte de procédure (ensemble d’instructions)
appartenant à une classe.

package java;
}
}
Une méthode peut prendre des paramètres de types précis et renvoie
19
Une méthode peut prendre des paramètres de types précis et renvoie
éventuellement une valeur de type tout aussi précis.
Le mot void signifie que la méthode main ne renvoie aucune valeur.
String[] args est le paramètre d’entrée de type String de la méthode
main.
Les mots public et static décrivent chacun une caractéristique de la
méthode (voir plus loin).

Plan
Concept Object
20
Les exceptions

Concept Object : Abstraction
L'abstraction dans l’approche objet permet la représentation des
entités du monde réel sous forme d’entités informatique de la
manière la plus naturelle.
Etablir une association entre le modèle du problème à résoudre et
le modèle de la machine :
21

L’abstraction est une représentation des éléments du monde
réel « objets réels » dans l'espace problème (la machine) en
tant qu'« objets informatiques ».
L'idée est d’adapter le programme à l'esprit du problème réel
en ajoutant de nouveaux types « objets ».
La complexité des problèmes et la capacité de les résoudrent
sont directement proportionnelles au type et à la qualité de nos
22
sont directement proportionnelles au type et à la qualité de nos
capacités d'abstraction.

Cette vision d’un objet peut être différente en fonction de nos
besoins :
Un conducteur voit une voiture comme un ensemble
complexe de commande pour la faire avancer, diriger et
interagir avec d’autres véhicules.
Un policier voit un ensemble de véhicule comme un
ensemble d’objet qui doivent respecter des règles de
23
ensemble d’objet qui doivent respecter des règles de
circulation. (camion ou voiture sont de même type)
Un garagiste voit un véhicule comme étant un ensemble
d’objets qui interagissent entre eux.

Concept Object : Approche Objet
Un objet est définit de la manière dont on peut interagir avec
lui et cela en fonction du problème à résoudre.
Il correspond a un certain niveau d’abstraction de la réalité et
est représenté essentiellement par les services qu’il peut nous
rendre.
24
Nous faisons tous en permanence un tel travail d’abstraction
pour pouvoir voir et comprendre simplement le monde qui
nous entour.
Un objet est encapsulé par son interface : la seule manière
d’interagir (demander un service) avec cet objet est
d’invoquer une des méthodes de son interface.

Un poste de Télévision moderne
est une boite ayant pour interface
: un écran, des haut parleurs et
une télécommande.
Exemple 1
25
Pour changer de chaîne il suffit
de demander à cette boite noire
de le faire pour nous, en
appuyant simplement sur le
bouton correspondant. Peu
importe ce qui se passe
réellement dans le poste.

R1 est un objet Rectangle de
hauteur 10 de largeur 20, ayant une
interface qui permet de calculer :
−le périmètre,
Exemple 2
26
−le périmètre,
−la surface,
−le diagonale
−et un dernier service pour dessiner
le rectangle.
Pour utiliser l’un de ces services il suffit d’invoquer la
méthode correspondante.

Une classe est un moule pour fabriquer des objets de même
structure et de même comportement.
En programmation, une classe apparaît donc comme un
nouveau type construit par l’utilisateur.
Le nom d’une classe peut être utilisé en Java comme le type
d’un attribut ou d’une variable ou aussi comme le type de retour
d’une méthode (fonction).
27
d’une méthode (fonction).
Le processus de création d’un objet à partir d’une classe est
appelé en jargon objet instanciation d’un objet ou création
d’instance d’une classe.
Exemple :
String message="Hello Java";
String est le nom de la classe, la variable message est un objet
instancié ou instances de la classe String.

Un objet a une durée de vie et une identité.
28

Concept Object : Encapsulation
Grâce au concept d'objet, il ne s'agit plus de déclarer des variables
puis un ensemble de fonctions destinées à les gérer de manière
séparée, mais de regrouper le tout sous le couvert d'une et même
entité. Il s'agit d'une forme d'encapsulation. Ainsi, l’encapsulation
d’un objet par son interface permet de masquer son contenu : i.e
montrer uniquement ce qui est nécessaire pour son utilisation.
29
Les données sont généralement considérées comme données
privées. Elle ne sont pas donc accessibles directement.
Les méthodes constituent l’interface d’interaction avec un objet
d’une classe. Elle sont donc accessibles (publiques).
Un objet n'est accessible qu’à travers l’interface de sa classe
Java propose plusieurs niveaux de visibilité (modificateur d’accès)
utilisable sur les données d'une classe pour assurer le principe de
l’encapsulation.

Concept Object : Encapsulation
Pour respecter ce principe d'encapsulation on ne doit interagir
avec un objet que par l’invocation d’une de ces méthodes de son
interface.
30
On dit à l’objet ce qu’il doit faire, sans se préoccupé de comment
il doit le faire.

Concept Object : Héritage
L'héritage est l’un des grands intérêts des langages orienté objet : pouvoir définir
des dépendances entres classes en factorisant les propriétés communes à plusieurs
classes.
Le concept d'héritage permet de construire une classe à partir d’une (ou plusieurs)
autre(s) classe(s) en partageant ses attributs et ses méthodes.
31
Grâce au concept d'héritage un objet article va pouvoir donner naissance à des
descendants (par exemple livre et disque).
Tout comme un enfant hérite des caractéristiques de ses parents et développe les
siennes, un objet (descendant) hérite des caractéristiques (attributs et méthodes)
de son ancêtre, mais aussi peut en développer de nouvelles, ou bien encore se
spécialiser. Ainsi, un livre est toujours considéré comme un article, il possède
donc un titre et un prix, mais il dispose également de deux attributs spécifiques
(ISBN et langue).

Les deux classes Personne et Forme sont appelées classe de base
Les classes Ouvrier, Etudiant et Chercheur héritent toutes
32
Les classes Ouvrier, Etudiant et Chercheur héritent toutes
les trois de la classe Personne.
Les classes Cercle, Rectangle et Triangle sont appelées des
classes dérivées de la classe Forme.

Intérêts
Spécialisation, enrichissement : une nouvelle classe réutilise les
attributs et les méthodes d’une classe en y ajoutant des attributs
et/ou des méthodes particulières.
Réutilisation : évite de réécrire du code existant ou de dupliquer du
code.
33
code.
Redéfinition : une nouvelle classe redéfinit les attributs et méthodes
d’une classe de manière à en changer le sens et/ou le comportement
pour le cas particulier défini par la nouvelle classe
Notez que bien souvent, on ne possède pas les sources de la classe
à hériter.

Concept Object : Polymorphisme
C’est un mot Greg « plusieurs formes ».
Le polymorphisme traite de la capacité de l'objet à posséder
plusieurs formes. Cette capacité dérive directement du principe
d'héritage vu précédemment (héritage des caractéristiques et
redéfinition de méthodes).
34

Concept Object
Pourquoi utiliser l’approche Objet
La motivation essentielle de cette approche est d'augmenter les
possibilités de réutilisation : L'encapsulation des données et du
code dans une même entité permet de garantir la cohérence des
objets. Cette cohérence est indispensable pour envisager de
réutiliser un objet dans un autre contexte.
35
La notion d'encapsulation par une interface permet de normaliser
le fonctionnement des objets : Il est possible de changer le
fonctionnement interne d'un objet particulier, sans modifier la
manière de l'utiliser (c'est à dire le reste du programme)

Concept Object
Pourquoi utiliser l’approche Objet
La notion d'héritage permet de réutiliser ce qui a déjà été défini
lors de la conception d'un objet pour en créer de nouveaux.
La notion de polymorphisme, permet de manipuler de manière
identique et la plus naturelle possible des objets ayant des
comportements totalement différents : des comportements qui ne
36
comportements totalement différents : des comportements qui ne
sont pas obligatoirement connus au moment où l'on définit ces
manipulations. Vouloir afficher un rectangle, un cercle ou un
triangle, on est toujours dans le même espace de problème, qui est
afficher une forme géométrique. C’est la manière d’afficher chaque
forme qui est différentes.

Plan
Concept Object
37
Les exceptions

Les bases du langage java : Commentaires
Tout programme (grand ou petit, simple ou complexe)
contient (ou devrait contenir) des commentaires.
Ils ont pour but d'expliquer :
Ce qu'est sensé faire le programme,
Les conventions adoptées,
Tout autre information rendant le programme lisible à soi
38
Tout autre information rendant le programme lisible à soi
même et surtout à autrui.
Java dispose de trois types de commentaires :
1. Les commentaires multi lignes,
2. Les commentaires lignes,
3. Les commentaires de type documentation.

Les commentaires lignes débutent avec les symboles
« // » et qui se terminent à la fin de la ligne.
Ils sont utilisés pour des commentaires courts qui
tiennent sur une ligne.
Commentaires multi lignes :
Commentaires en lignes
39
Commentaires multi lignes :
Un commentaire multi ligne commence par les caractères
« /* » et se terminent par « */ ».
A l'intérieur de ces délimiteurs toute suite de caractères
est valide (sauf évidemment « */ »).

Ces commentaires, appelés aussi commentaires javadoc, servent à documenter les
classes que l'on définit.
Ces commentaires sont encadrés entre « /**» et « */ ».
Java exige que ces commentaires figurent avant la définition de la classe, d'un
membre de la classe ou d'un constructeur.
Ces commentaires servirons à produire automatiquement (avec l'outil javadoc) la
documentation sous forme HTML à l'image de la documentation officielle de
SUN.
40
SUN.
/**
* The HelloWorldApp class implements an application that
* simply prints "Hello World!" to standard output.
*/
class HelloWorldApp {
System.out.println("Hello World!"); // Display the string.
}
}

Les bases du langage java : Type de données
Le langage Java est un langage fortement typé : Chaque variable et
chaque expression possède un type bien défini.
Le choix d’un type est en fonction de l'étendu de valeur souhaitée
pour vos variables.
Les types de données de Java sont divisés en deux grands groupes :
Les types primitifs (ou de base)
41
Les types primitifs (ou de base)
Exemple : Les types numériques, le type booléen, Le type caractère.
Les types références.

Data Type Nombre d’octet Valeur par défaut Domaines de valeurs
byte 1 0 -128 à 127
short 2 0 -32768 à 32767
int 4 0 -2 147 483 648 à 2 147 483 647
long 8 0L (L ou l)
-9 223 372 036 854 775 809 à 9
223 372 036 854 775 807
char 2 (code Unicode) 'u0000' 0 à 65536
42
char 2 (code Unicode) 'u0000' 0 à 65536
float 4 0.0f (F ou f) -1.4*10-45 à 3.4*1038
double 8 0.0d (D ou d) 4.9*10-324 à 1.7*10308
boolean 1 false true ou false
Le bit y est utilisé pour décrire les tailles.
Un bit ne peut prendre que deux valeurs (0 ou 1).
n bits ne peuvent définir que 2n valeurs.
Un octet ou byte en anglais = 8 bits.
Un octet peut donc contenir 28 (soit 256) valeurs distinctes.

Le type primitif booléen
Ce type est introduit en Java par le mot clé boolean.
Ce type est un vrai type booléen, il accepte seulement deux
états :
l'un est nommé true : Symbolise un état d'acceptation,
l'autre, nommé false: Symbolise un état de réfutation.
43
l'autre, nommé false: Symbolise un état de réfutation.
Attention, contrairement du langage C, le type booléen en
Java n'est pas un sous-type numérique. En C par exemple , la
valeur 0 est considérée comme fausse et les autres valeurs
entières comme vraies.

Le type primitif caractère
Ce type, introduit par le mot clé char, et permet la gestion des
caractères.
Java utilise le codage de caractères universel Unicode qui est
une extension du codage ASCII.
44
Le codage ASCII utilise 8 bits et permet de représenter
seulement 128 caractères.
Le codage Unicode permet la portabilité du code produit. Il
utilise 16 bits pour représenter un caractère.
65536 caractères possible.
Codage des caractères d’alphabets Cyrillique, Hébreux,
Arabe, Chinois, Grec, etc.

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
A partir de la version Java SE 7 on peut ajouter un « underscore » dans les types
primitives
45
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;
Vous pouvez placer souligne seulement entre les chiffres, vous ne pouvez pas
placer de soulignement dans les endroits suivants:
Au début ou à la fin du nombre
Adjacent à un point décimal en virgule flottante
Avant un suffixe F ou L
Dans les positions où l'on prévoit une chaîne de chiffres

Les types références
Tout type non primitif, est un type de référence.
Le rôle d’un type de référence est de référencer ou repérer
une zone mémoire.
46
une zone mémoire.

Syntaxe : Type identificateur [= constante ou expression];
int nbrMois = 12;
int nbrDoigt = 012; //on octal egale à 10 en décimal
int annee = 0x7d4;///on hexadécimal egale à 2004 en décimal.
boolean trouve = true;
Déclaration et initialisation des variables
47
boolean trouve = true;
float solde = 5.3f;
float salaire = 8.5e+2f;
double unDouble = 1.2;
char caractere='A';
char newLine = 'n';
String message="Hello Java";
String n'est pas un type primitif, mais une classe

Les bases du langage java : Les opérateurs
Les opérateurs dans Java sont regroupés par :
type d’opérations :
−d’affectation,
−numérique,
−de comparaison,
−logique,
48
−logique,
−sur les chaînes de caractères,
−de manipulations binaires.
le nombre d’opérandes :
−unaire,
−binaire,
−ternaire.

Opérateurs
unaires
Action Exemple
- négation i=-j
++ incrémentation de 1 i=j++ ou i=++j
-- décrémentation de 1 i=j-- ou i=--j
Les bases du langage java : Opérateurs unaires
49
++ et -- peuvent préfixer ou postfixer la variable.
i = j++ : post-incrémentation
La valeur en cours de j est affectée à i et ensuite la valeur de j est
incrémentée de 1.
i = ++ j : pré-incrémentation
La valeur en cours de j est incrémentée de 1 et ensuite la valeur de j
est affectée à i.

Opérateurs
binaires
Action Exemple Syntaxe
équivalent
+
Addition
i=j+k
+= i+=3 i=i+3
-
Soustraction
i=j-k
-= i-=j i=i-j
* x=4*y
Les bases du langage java : Opérateurs binaires
50
*
Multiplication
x=4*y
*= x*=y x=x*y
/ division i =j/k; (tronque
si les arguments sont
entiers)
i=j/k
/= x/=10 x=x/10
%
Modulo
i=j%k
%= i%2=0 i=i%2
>> Décalage vers la droite i>>k; i*2k
<< Décalage vers la
gauche
i<<k; i/2k (si i>0)

Le résultat d'une comparaison est une valeur booléenne (vrai ou faux).
Opérateurs
relationnels
Action Exemple
< Plus petit que x<y
<= plus petit ou égal que i<=20
Les bases du langage java : Opérateurs relationnels
51
<= plus petit ou égal que i<=20
> Plus grand que J>100
>= Plus grand ou égal que ‘A’>=‘a’
== Égal à i==20
!= Différent de c!=‘C’

Les bases du langage java : Opérateurs logiques
Opérateurs
logiques
Action Exemple
! Négation !p
& ET p & (i<10)
| OU p | q
^ OU exclusif p ^ false
~ Complément
52
&& ET évalué p && q && r
|| Ou évalué p || q || r
!= négation assignée p!=q;
&= ET assigné p&=q
|= OU assigné p|=q
Dans le cas d’un opérateur logique évalué, l’évaluation de
l’expression logique est stoppée dès que sa valeur de vérité peut
être assurée.

Les bases du langage java : Opérateurs ternaires
Cette expression est une sorte de si-alors-sinon sous forme
d'expression :
a = (condition e) ? x : y
si la condition e est vraie alors a vaut x sinon elle vaut y.
53
Exemple : a = (valeur == 2) ? 1 : 0;
Cette expression affecte à la variable a la valeur 1 si v vaut 2,
sinon affecte à la variable a la valeur 0.

Les bases du langage java : Structures de contrôle
Structures de contrôle conditionnelle : if
if (expression booléene ) instruction ;
public class TestIf {
int i = 4;
if (i % 2 != 0) {
54
if (i % 2 != 0) {
System.out.println("L'entier " + i + " est impaire");
}
}
}
Attention : L'expression logique attendue est obligatoirement de
type boolean.
si l'on écrit if ( i = 1 ), le compilateur détectera une erreur, car le
type de l'expression logique est alors int.

Structures de contrôle conditionnelle : if-else
public class TestIfElse {
int i = 4;
boolean paire = (i % 2 == 0) ? true : false;
if (paire) {
55
(paire) {
System.out.println("L'entier " + i + " est paire");
} else {
System.out.println("L'entier " + i + " est impaire");
}
}
}

Structures de contrôle conditionnelle : if-else-if
public class TestIfElseIf {
int i = 4;
int j = 8;
if (i == j) {
56
if (i == j) {
System.out.println("i égale à j");
} else if (i > j) {
System.out.println("i est supérieur à j");
} else {
System.out.println("i est inférieur à j");
}
}
}

Structures de contrôle conditionnelle : switch
public class TestSwitch {
int i = 2;
switch (i) {
case 0:
System.out.println(" 0 ");
break;
57
break;
case 1:
break;
case 2:
break;
default:
System.out.println(i);
break;
}
}
}

Structures de contrôle itératif : for
for (initialization; termination; increment)
{
statement(s);
}
// boucle infinie
Les trois expressions de la boucle
58
Fonctionnement :
−initialisation du compteur,
−comparaison avec max,
−réalisation des instructions,
−Incrémentation du compteur et on recommence
// boucle infinie
for ( ; ; ) { // votre code}
Les trois expressions de la boucle
for sont facultatives; une boucle
infinie peut être créé comme suit:

Structures de contrôle itératif : for
public class TestFor {
int sum = 0;
for (int compteur = 0,maxValue = 5 ; compteur < maxValue; compteur++) {
sum+=compteur;
}
System.out.println("la somme est :"+sum);
59
System.out.println("la somme est :"+sum);
}
}

Structures de contrôle itératif : for-each
public class TestForEach {
int[] test = new int[]{1,4,5,7};
int sum = 0;
for (int intValue : test) {
60
for (int intValue : test) {
sum+=intValue;
}
System.out.println("La somme est : "+sum);
}
}

Structures de contrôle itératif : while
public class TestWhile {
int compteur = 0;
int sum = 0;
int maxValue = 5;
while(compteur<maxValue)
61
while(compteur<maxValue)
{
sum+=compteur;
compteur++;
}
}
}

Structures de contrôle itératif : do-while
public class TestDoWhile {
int compteur = 0;
int sum = 0;
int maxValue = 5;
do
{
62
{
sum+=compteur;
compteur++;
}while(compteur < maxValue);
}
}

Les instructions de branchement : break (non étiquetés)
L'instruction break a deux formes: étiquetés et non étiquetés.
Vous avez vu la forme non étiquetés dans la discussion précédente
de l'instruction switch.
Eventuellement on peux l’utiliser dans d’autres contextes. Par
63
Eventuellement on peux l’utiliser dans d’autres contextes. Par
exemple, pour sortir d’une structure de boucle avant que la
condition du test soit remplie. Quand la boucle rencontre une
instruction break, elle se termine immédiatement en ignorant le
code restant.

public class TestBreakFor {
int sum = 0;
for (int compteur = 0, maxValue = 5; compteur < maxValue; compteur++) {
if (compteur == 3)
break;
64
break;
sum += compteur;
}
System.out.println("la somme est :" + sum);
}
}

public class TestBreakWhile {
int compteur = 0;
while (compteur < 10) {
System.out.println(compteur);
compteur++;
65
compteur++;
if (compteur == 5)
break;
}
}
}

Les instructions de branchement : continue
L'instruction continue ignore l’exécution de l'itération actuelle
d'un for, while ou do-while à partir de son exécution. Elle
ignorer le reste de la boucle et de reprendre l’exécution à
l’itération suivante de la boucle.
public class TestContinue {
66
int sum = 0;
for (int compteur = 0,maxValue = 10 ; compteur < maxValue; compteur++) {
if(compteur==5)
continue;
System.out.println(compteur);
}
}
}

Les instructions de branchement : return
Le type de données de la valeur retournée doit correspondre au type de la
valeur de retour déclarée de la méthode.
public double getDistancePoint()
{
return 0;
67
Quand une méthode est déclarée void, utilisez la forme de retour qui ne
retourne pas de valeur. return;
public void doSomething()
{
return;
}
return 0;
}

Les bases du langage java : Conversion de type
Il y a 2 catégories de conversions possibles :
Conversions explicites : celles faites sur une demande
explicite par un programmeur.
Conversions implicites : celles faites automatiquement par
68
Conversions implicites : celles faites automatiquement par
un compilateur :
−lors d'une affectation,
−lors d'une promotion arithmétique,
−lors d'un passage de paramètres (lors de l'invocation d'une
méthode),

Conversion explicite :
Objectif : changer le type d'une donnée si besoin.
Comment ?
−Préfixer l’opérande par le type choisi.
−Encadrer le type choisi par des parenthèses.
69
−Encadrer le type choisi par des parenthèses.
Exemple :
double d = 2.5 ;
long l = (long) d ;
System.out.println("d = "+d+" ; l="+l);
d = 2.5 ; l=2

Conversion implicite lors d'une affectation :
Exemple 1 :
public class TestConversionImplicite {
int i;
short j = 2 ;
i = j ; Conversion implicite
70
i = j ;
float k = 1.2f ;
}
}
Conversion implicite
Erreur compilation
i = (int) k;

public class TestConversionImplicite2 {
int i;
i = 'A';
System.out.print(i);
Conversion implicite lors d'une affectation :
Exemple 2 :
}
}
71

int i;
i = 'A'-1;
Conversion implicite lors d'une promotion arithmétique :
Exemple :
}
}
72

public static void affiche(int numero)
{
Conversion implicite lors d'un passage de paramètres (lors
de l'invocation d'une méthode) :
Exemple :
{
System.out.println(numero);
}
Short numero=2;
affiche(numero);
}
}
73
Invocation méthode affiche :
Conversion implicite du paramètre

Erreur compilation
Attention :
Il n'y a pas de conversion possible (implicite ou explicite) entre
un type entier et le type boolean
int i = 0;
if (i) {
74
Erreur compilationif (i) {
}
if (i != 0) {
}
OK

Plan
Concept Object
75
Les exceptions

Les classes constituent le concept de base de la programmation objet.
Une classe est le support de l'encapsulation : c'est un ensemble de
données et de fonctions regroupées dans une même entité. Une classe
est une description abstraite d'un objet.
Les classes permettent de définir des nouveaux types de données
76
Les classes permettent de définir des nouveaux types de données
qui doivent se comporter comme des types prédéfinis et dont les
détails d'implantation sont cachés aux utilisateurs de ces classes.
Java est un langage orienté objet : tout appartient à une classe sauf
les variables de types primitives.
Une définition de classe est introduite par le mot clé class.

En Java, pour déclarer une classe on utilise le mot-clé class
suivi du nom de la classe.
1. La première lettre du nom d’une classe doit toujours être
public class EtudiantEpi {
}
77
1. La première lettre du nom d’une classe doit toujours être
une lettre majuscule (ex : Chat).
2. Mélange de minuscule, majuscule avec la première lettre
de chaque mot en majuscule (ex : EtudiantEpi ).
3. Une classe se trouve dans un fichier portant son nom suivi
l’extention .java (ex : EtudiantEpi .java)

Une classe java définit généralement deux choses :
Les données associées aux objets de la classe appelés champs ou
attribut de la classe,
Les services que peuvent rendre les objets de cette classe
interactifs, qui sont les méthodes définies dans la classe.
78
interactifs, qui sont les méthodes définies dans la classe.

En général, les déclarations de classe peuvent inclure ces composants dans l'ordre:
1. Modificateurs tels que public et private, final et abstract.
public class EtudiantEpi extends Personne implements Cours{
// Attribut(s), Constructeur(s)
// Déclaration des méthode(s)
}
79
2. Le nom de la classe, avec la lettre initiale capitalisée par convention.
3. Le nom de la classe mère (super class), si existe, précédé par le mot-clé
extends. Une classe ne peut héritée que d’une seule classe
4. Une liste séparée par des virgules des interfaces implémentées par la classe, si
existe, précédé par le mot-clé implements. Une classe peut implémenter
plusieurs interfaces
5. Le corps de la classe, entouré par des accolades, {}.

public class Date {
private int jour;
private int mois;
private int annee;
public void initialise(int j,int m, int a)
{
jour=j;
80
jour=j;
mois=m;
annee=a;
}
public void affiche()
{
System.out.println(jour+"/"+mois+"/"+annee);
}
}

Classes et objets java : Class Vs Object
Il est important de saisir les différences entre les notions de classe
et instance de la classe (Object) :
classe = attributs + méthodes + mécanismes d’instanciation +
mécanismes de destruction
instance de la classe = valeurs des attributs + accès aux méthodes
81
L’instanciation est le mécanisme qui permet de créer des instances
dont les traits sont décrits par la classe.
La destruction est le mécanisme qui permet de détruire une
instance de la classe.
L’ensemble des instances d’une classe constitue l’extension de la
classe.

Classes et objets java : Modificateurs de visibilité
En Java, l’encapsulation est assurée par un ensemble de
modificateurs d’accès permettant de préciser la visibilité des
membres de la classe :
Un membre dont la déclaration est précédée par le mot clé
public est visible depuis toutes instances de toutes classes.
82
Un membre dont la déclaration est précédée par le mot clé
private n’est visible que dans les instances de la classe.

Le mot clé public permet d’indiquer les services qui sont
accessibles à l’utilisateur.
public class Question {
public void repondre(int reponse)
{
}
83
}
public boolean isReponseCorecte()
{
return true;
}
public String toString()
{
return null;
}
}

Le mot clé private assure l’encapsulation
// intitulé de la question
private String question ;
// tableau des choix possibles
private String [ ] choix ;
// numéro de la réponse de l’étudiant
84
private int reponse ;
// numéro de la bonne réponse
private int bonneReponse ;
public void repondre(int reponse){ }
public boolean isReponseCorecte(){return true;}
public String toString(){return null;}
}

Les modificateurs de visibilité sont valable pour un attribut ou
une méthode :
public : accessible à partir d’une instance par n’importe quelle
classe.
private : accessible uniquement par les méthodes de la classe.
85
private : accessible uniquement par les méthodes de la classe.
protected : accessible par la classe et ses classes dérivées.
static : donnée ou méthode de classe et non pas d’instance.

final :
−Une classe définie comme final ne peut pas être dérivée (on ne
peut pas créer une nouvelle classe héritant de cette classe).
−Une méthode déclarée final ne peut pas être redéfinie dans une
classe dérivée.
−Un attribut définie comme final, permet de spécifier que cet
86
attribut est une constante (sa valeur ne pourra jamais être modifiée).
−Un attribut final doit obligatoirement être initialisée lors de sa
déclaration (puisqu'on ne peut pas le modifier après cela ).
Exemple : déclaration des constantes en Java.
private static final long MAX_VALUE = 1L;
rien :
Par défaut public.

NB1 : static cumulable avec d’autres modificateurs.
NB2 : Un attribut ou une méthode de classe est appelée à
travers la classe et non pas par l’instance.
NB3 : Un paquetage (package) est un regroupement
87
thématique de classes.
NB4 : Sans modificateur de visibilité, un attribut ou une
méthode est appelée amie.

88

Classes et objets java : Accès aux membres d’une classe.
L’ensemble des méthodes d’un objet accessibles de l’extérieur
(depuis un autre objet) est appelé interface. Elle caractérise le
comportement de l’objet.
L’accès à un membre d’une classe se fait au moyen de
l’opérateur « . ».
89
L’invocation d’une méthode d’interface est appelé appel de
méthode. Il peut être vu comme un envoi de message entre
objet.

Classes et objets java : Membres d’instance et de classes
Quelque soit le niveau de visibilité, on distingue deux types de
membres : membre d’instance et membre de classe.
Un membre de classe est un membre commun à toutes les
instances de la classe et existe dès que la classe est définie en
dehors et indépendamment de toute instanciation. Les membres
de classe sont déclarés à l’aide du mot-clé static.
90
de classe sont déclarés à l’aide du mot-clé static.
Un membre qui n’est pas de classe, i.e. dont la déclaration n’est
pas précédée du mot-clé static est dit membre d’instance.
Chaque instance d’une classe possède son propre exemplaire
d’un attribut d’instance de la classe.

On veut introduire des choix par défaut
private String [ ] choix = {"vrai","faux"};
}
Problème : chaque instance dispose de son propre tableau choix
91
Problème : chaque instance dispose de son propre tableau choix
alors qu’il devrait être commun à tous les objets.
private static String [ ] choix = {"vrai","faux"};
}

Les membres de classes d’une classe donnée étant communs à
toutes les instances de la classe, l’accès à un membre de classe se
fait en appliquant l’opérateur « . » sur le nom de la classe.
System.out.println(Question.choix[0]);
L’accès aux membres de classe peut aussi se faire avec une
92
L’accès aux membres de classe peut aussi se faire avec une
instance de la classe suivie de l’opérateur « . ». Mais ceci est
peu lisible.

Classes et objets java : Les membres
Une classe java contient trois grands types de membres :
public class Point {
// (1) Attributs
private double x = 0;
private double y = 0;
// (2) Constructeur
93
// (2) Constructeur
public Point() {
}
// (3) Methode
public double distanceAvec(Point p2 )
{
return 0;
}
}

Classes et objets java : Attribut
La déclaration des attributs se fait de préférence en début de classe et leurs noms
commencent par des minuscules.
On indique au compilateur :
1. Un ensemble de modificateurs (facultatif ).
2. Le type de la variable.
3. Le nom de la variable.
Pour respecter le principe de l’encapsulation, les attributs doivent :
94
toujours être déclarés privés :
private int longeur ;
être accédé en lecture par un accesseurs en lecture :
public int getLongeur() ;
être accédé en écriture par un accesseurs en écriture :
public void setLongeur(int longeur) ;

Classes et objets java : Attribut
// intitulé de la question
private String question ;
private String [ ] choix ;
question, choix, reponse et bonneReponse
sont les attributs de la classe Question
95
public void repondre(int reponse){ }
public boolean isReponseCorecte(){return true;}
public String toString()
{
String message= null;
return message;
}
}
message est une variable non pas
un attribut

Classes et objets java : Attribut (Accesseurs & Mutateurs)
/**
* @return the x
*/
public double getX() {
return x;
}
/**
* @param x the x to set
*/
public void setX(double x) {
Un accesseur est une méthode qui va nous
permettre d'accéder aux variables de nos objets
en lecture, et un mutateur nous permettra d'en
faire de même en écriture ! Grâce aux
accesseurs, vous pourrez afficher les variables
de vos objets, et grâce aux mutateurs, vous
pourrez les modifier.
96
public void setX(double x) {
this.x = x;
}
/**
* @return the y
*/
public double getY() {
return y;
}
/**
* @param y the y to set
*/
public void setY(double y) {
this.y = y;
}
pourrez les modifier.
Généralement, lorsqu'on parle d'accesseurs, ce
terme inclut également les mutateurs. Autre
chose : il s'agit ici d'une question de convention
de nommage. Les accesseurs commencent par
get et les mutateurs par set. On parle d'ailleurs
parfois de Getters et de Setters.

Classes et objets java : Constructeur
Les instances d’une classe sont créées (construits) par une méthode particulière de
la classe appelée constructeur.
Un constructeur est une méthode spéciale d’initialisation d’un objet
Un constructeur est une méthode qui n’a pas de type de retour.
Un constructeur porte le même nom que la classe.
Une classe peut avoir plusieurs constructeurs qui diffèrent par le nombre et la
97
Une classe peut avoir plusieurs constructeurs qui diffèrent par le nombre et la
nature de leurs paramètres (principe de surcharge).
Le constructeur sera automatiquement appelée à l’instanciation de la classe, i.e.
au moment de la création d’un objet.
Les constructeurs permettent, entre autres, d’initialiser les attributs de la classe.
La surcharge peut être appliquer pour n’importe quelle méthode et pas seulement
pour les constructeurs.

Classes et objets java : Constructeur
public Point(int x,int y) {
this.x=x;
this.y=y;
}
public Point(){
Constructeur avec paramètres
Constructeur sans paramètres
98
public Point(){
x=0;
y=0;
}
}
Constructeur sans paramètres

Classes et objets java : Invocation
La création d’une variable instance d’une classe nécessite deux
opérations :
La création d’une référence qui ne pointe sur rien:
Point point1; Point point3= null;
La réservation de la place mémoire à l’aide de l’opérateur new
avec l’un des constructeurs de la classe :
99
Point point1 = new Point(2,3);
Point point2 = new Point();
point3= new Point(2,3);
Cette invocation :
1. alloue l’espace mémoire nécessaire pour stocker les propriétés
2. crée une référence sur cet espace mémoire
3. exécute le code du constructeur pour initialiser les données
4. retourne la référence ainsi créée.

Classes et objets java : Constructeur par défaut
Règle : Toute classe possède au moins un constructeur.
En absence de déclaration explicite d’un constructeur, un
constructeur par défaut sera automatiquement ajouté par le
compilateur Java.
La notion de constructeur par défaut est en partie lié à l’héritage.
100
La notion de constructeur par défaut est en partie lié à l’héritage.
Dans un premier temps, on retiendra qu’un constructeur par
défaut :
1. initialise les attributs numérique de types primitif à 0 ;
2. initialise les attributs de (boolean) à false ;
3. initialise les attributs de types Objet à null.

public void affiche()
{
System.out.println("X="+x+" ; Y="+y);
}
}
101
public class TestPoint {
Point point=new Point();
point.affiche();
}
}

Le constructeur par défaut n’est ajouté par Java si et seulement
s’il n’y a pas de constructeur explicite.
Une classe ne possède donc pas toujours un constructeur sans
paramètre.
Si l’on en veut un en plus d’un constructeur à paramètre, il faut
102
Si l’on en veut un en plus d’un constructeur à paramètre, il faut
le déclarer explicitement.

Classes et objets java : Surcharge de Constructeur
Si une classe a plusieurs constructeurs, il s’agit de surcharge :
même nom (celui de la classe)
types des paramètres différents.
103

Classes et objets java : Surcharge de Constructeur
public Question(String question, String[] choix, int bonneReponse) {
this.question = question;
this.choix = choix;
this.bonneReponse = bonneReponse;
this.reponse = 0;
}
public Question(String question, String[] choix) {
this.choix = choix;
104
this.choix = choix;
this.bonneReponse = 0;
this.reponse = 0;
}
public Question() {
this.question = null;
this.choix = null;
this.bonneReponse = 0;
this.reponse = 0;
}

Classes et objets java : Constructeurs imbriqués
On peut utiliser un constructeur pour définir un autre
constructeur, au moyen du mot-clé this, mais cette invocation
d’un autre constructeur doit être la première instruction.
public Question(String question, String[] choix, int bonneReponse) {
this.choix = choix;
105
this.reponse = 0;
}
public Question(String question, String[] choix) {
this(question, choix, 0);
}
public Question() {
this(null, null, 0);
}

Classes et objets java : Le mot clé this
Le mot-clé this représente une référence sur l'objet courant.
Dans le corps d’une méthode, le mot clé this désigne l’instance
sur laquelle est invoquée la méthode.
Ce mot clé est utilisé dans 5 circonstances :
1. Pour accéder aux attributs de l’objets.
2. Pour lever des ambiguïtés entre des noms d’attributs et des
106
2. Pour lever des ambiguïtés entre des noms d’attributs et des
noms d’arguments de méthodes (Lorsqu'une variable locale
(ou un paramètre) cache, en portant le même nom, un attribut
de la classe).
3. Pour comparer la référence de l’objet invoquant la méthode à
une autre référence.
4. Pour passer la référence de l’objets invoquant la méthode en
paramètre d’une autre méthode.
5. Pour déclencher un constructeur depuis un autre constructeur.

Dans le corps d’une méthode, this permet d’accéder aux attributs de
l’objet lorsque ceux-ci sont masqués par un paramètre ou par une
variable locale.
107
public void repondre(int reponse)
{
this.reponse=reponse;
}
public boolean isReponseCorecte()
{
return this.reponse== bonneReponse;
}
}

Dans le corps d’une méthode, this permet de comparer la référence
de l’objet sur lequel est invoqué la méthode à une autre référence.
public class Animal {
Estomac estomac ;
public void manger ( Animal victime ) {
108
public void manger ( Animal victime ) {
// On ne peut pas se manger complètement soi- même
i f ( this != victime ) {
estomac.addNouriture( victime) ;
}
}
}

Les noms de variables sont sensibles à la casse. Le nom d'une variable peut être n'importe
quel identifiant légal : une séquence de longueur illimité de lettres et de chiffres, en
commençant par une lettre, le signe dollar « $ » ou le caractère de soulignement « _ ».
Le convention, cependant, est à toujours commencer vos noms de variables avec une lettre,
et non pas « $ » ou « _ ». En outre, le caractère de signe dollar, par convention, n'est jamais
utilisée du tout. A convention semblable existe pour le caractère de soulignement; tandis que
c'est techniquement juridique pour commencer à le nom de votre variable avec "_", cette
pratique est découragée. L'espace blanc n'est pas autorisée.
Lors du choix d'un nom pour vos variables, utilisez des mots complets au lieu des
Les conventions de codage
109
Lors du choix d'un nom pour vos variables, utilisez des mots complets au lieu des
abréviations cryptiques. Cela rendra votre code plus facile à lire et à comprendre. Dans de
nombreux cas il sera également à rendre votre code d'auto-documentant; champs nommés
nom, prenom, et age, par exemple, sont beaucoup plus intuitive que versions abrégés, les tels
que n, p, et a. Aussi garder à l'esprit que le nom que vous choisissez ne doit pas être un mot clé
ou d'un mot réservé.
Si le nom que vous choisissez est constitué d'un seul mot, épeler ce mot en lettres
minuscules. Si elle se compose de plus d'un mot, la première lettre de chaque mot suivant doit
être en majuscule. Si votre variable stocke une valeur constante, comme static int final
MAX_ADMIS = 6, les modifications de conventions légèrement, en capitalisant chaque lettre
et séparant les mots suivants avec le caractère de soulignement. Par convention, le caractère de
soulignement n'est jamais utilisé ailleurs (seulement dans la version JDK7 avec les nombres).

Classes et objets java : Destruction d’objet
La plupart des langages orientés objet possèdent une méthode
nommée destructeur, appelée pour détruire un objet.
La destruction d’un objet consiste à libérer les ressources qui lui
ont été déjà affectées par le constructeur. Un objet est détruit
lorsqu’il ne référencie aucune zone mémoire.
110
En Java, la destruction des objets est prise en charge par un
mécanisme automatique appelé ramasse-miettes (garbage
collector GC).
Le GC fonctionne en arrière plan pendant l'exécution d'un
programme Java. il est géré dans une thread de faible priorité. Il
est difficile de savoir à quel moment le GC détruira réellement
votre objet.

La récupération de mémoire peut être aussi invoquée
explicitement par le programmeur à des moments bien précis avec
la commande System.gc().
Certaines situations nécessitent un nettoyage spécial que le GC ne
peut pas effectuer :
Par exemple, certains fichiers ont été ouverts pendant la durée de
111
Par exemple, certains fichiers ont été ouverts pendant la durée de
vie de l’objet et vous voulez vérifier qu’ils sont correctement
fermés quand l’objet est détruit.
Pour cela, une autre méthode spéciale, appelée finalize(), peut
être définie. Cette méthode (si elle est présente) est appelée par le
GC lorsque l'objet est détruit pour assurer ce type de nettoyage
spécial.

public class Date {
private int jour;
private int mois;
private int annee;
public Date(int jour, int mois, int annee) {
this.jour = jour; this.mois = mois;this.annee = annee;
}
public Date() {
this(1,1,2013);
}
112
}
public void finalize() {
System.out.println("Nettoyage spéciale");
}
Date date=new Date();
date.affiche();
date=null;
//Appel implicite du GC
System.gc();
}}
date ne désigne plus rien, il ne possède plus de
référence.
Elle n'est plus accessible. A tout moment le GC
peut détruite l'objet.

public class Date {
private int jour;
private int mois;
private int annee;
}
public Date() {
this(1,1,2013);
}
113
}
}
date.affiche();
Date date2=date;
date=null;
System.gc();
}}

public class Date {
private int jour;
private int mois;
private int annee;
}
public Date() {
this(1,1,2013);
}
114
}
}
date.affiche();
Date date2=date;
date=null; date2=null;
System.gc();
}}

Classes et objets java : Comparaison d’instance
Utilisation de l’opérateur == :
Date date1=new Date(1,1,2014);
boolean egale=(date1==date2)?true:false;
System.out.println(egale);
}
Exemple 1:
Exemple 2:
115
Date date2=date1;
boolean egale=(date1==date2)?true:false;
}
Pour comparer le contenu de deux objets il faut utiliser la méthode equals :
boolean egale=(date1.equals(date2))?true:false;
}

Classes et objets java : Mode de passage des paramètres
Le mode de passage des paramètres dans les méthodes dépend
de la nature des paramètres :
par référence pour les objets,
par copie pour les types primitifs.
116

Classes et objets java : Les opérateurs sur les références
Les seuls opérateurs sur les références sont des opérateurs
logiques :
== : permet de tester si deux références désignent le même
objet.
!= : permet de tester si deux références ne désignent pas le
117
!= : permet de tester si deux références ne désignent pas le
même objet.
equals: permet de comparer le contenu de deux références.
instanceof: permet de tester si l'objet référencé est une
instance d'une classe donnée ou d'une de ses sous-classes:
boolean egale=(date1 instanceof Date)?true:false;

Plan
Concept Object
Les bases du langage java (suite)
118
Les exceptions

Les bases du langage java : Tableau
En java le type tableau est assimilable à une classe et un tableau
est un objet référencé.
Un objet tableau ne référence pas l’objet lui-même mais
uniquement l’adresse mémoire a qui il fait référence.
Déclarer un tableau en java revient a réserver de la place
119
Déclarer un tableau en java revient a réserver de la place
mémoire pour l’adresse de ce tableau.
Pour créer un tableau il faut lui allouer l’espace mémoire
nécessaire après l’avoir déclaré.

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
Tableau à une dimension : Déclaration
120
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Remarque : Vous pouvez également placer les crochets
après le nom du tableau. Mais cette forme est déconseillée

Tableau à une dimension : Création
La déclaration ne fait que réserver l’espace mémoire allant
contenir l’adresse du tableau.
Cette place mémoire est identifié par le nom du tableau.
l’allocation de la place mémoire se fiat par le mot clé new :
<nomTableau> = new <Type>[<dimension>];
121
<nomTableau> = new <Type>[<dimension>];
Exemple : anArrayOfDoubles =new double[10];

Tableau à une dimension : Initialisation
Lorsqu’un tableau est créé. Chacun de ces éléments est
initialisé. Cette initialisation se fait a 0 si les éléments sont
des entiers ou des réels. A false s’ils sont des booléens et a
null sinon.
int [] indice=new int[3];
122
indice[0]=5;
indice[1]=15;
indice[2]=25;
int [] indice={5,15,25};
int [] indice=new int[]{5,15,25};

Un tableau est un objet conteneur qui contient un nombre fixe
de valeurs d'un type unique. La longueur d'un tableau est
établi lorsque le tableau est créé. Après la création, sa
longueur est fixe.
Tableau à une dimension : Utilisation
123
La longueur d’un tableau peut être obtenue à partir de la
variable membre length.
indice.length;

le premier élément d’un tableau commence a l’indice 0 et le
dernier élément a l’indice n-1 (n le nombre d’éléments du
tableau).
L’accès à un éléments du tableau se fait en mettant l’indice de
cet élément entre crochets. Par ailleurs si on essaie d’accédé à
un élément qui ce trouve en dehors des bornes du tableau une
Tableau à une dimension : Utilisation
124
un élément qui ce trouve en dehors des bornes du tableau une
exception sera générée.
indice[10]=5; // Erreur d’exécution
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
at javaepi.TestArray.main(TestArray.java:6)

Tableau à une dimension : Affichage
import java.util.Arrays;
public class TestArray {
int [] indice=new int[]{1,2,3};
for(int i=0;i<indice.length;i++)
{
System.out.print(indice[i]+" ,");
125
System.out.print(indice[i]+" ,");
}
System.out.println();
for(int value:indice)
{
System.out.print(value+" ,");
}
System.out.println();
System.out.println(Arrays.toString(indice));
}
}

Tableau à une dimension : Copie de tableau
public class TestArrayCopy {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
126
}
}

Tableau à deux dimensions : Déclaration & création
Un tableau a 2 dimensions est tableau dont chaque
composantes est formée par un tableau.
int [][] indice=new int[3][];
127
int [][] indice=new int[3][];
indice [0]=new int[1];
}

Tableau à deux dimensions : Déclaration & création
Si le tableau a deux dimension est rectangulaire, on peut le
créer comme suit :
int [][] indice=new int[3][3];
indice [0][0]=1;
indice [0][1]=2;
128
indice [0][1]=2;
indice [0][2]=3;
indice [1][0]=4;
indice [1][1]=5;
indice [1][2]=6;
indice [2][0]=7;
indice [2][1]=8;
indice [2][2]=9;
}

Tableau à deux dimensions : Taille
La taille d’un tableau à deux dimension est obtenue comme suit :
System.out.println(indice.length);
System.out.println(indice[0].length);
129
int[][]indice2=new int[][]{{1,2,3,4},{0},{5,6}};
System.out.println(indice2.length);
System.out.println(indice2[0].length);
int[][]indice3=new int[][]{new int[3],new int[2]};
}

Tableau à deux dimensions : Affichage
System.out.println(indice.length);
130
int[][]indice2=new int[][]{{1,2,3,4},{0},{5,6}};
System.out.println(indice2.length);
System.out.println(Arrays.deepToString(indice));
System.out.println(Arrays.deepToString(indice2));
}

Si l’on déclare un tableau dont les éléments sont des
références de type Point :
Point [] polygone;
Alors, la ligne de commande
polygone=new Point[10];
131
polygone=new Point[10];
instancie un tableau de 10 références initialisées à null. Si l’on
veut qu’une case contienne une référence vers une instance de
la classe Point, on doit instancier une instance de la classe
Point et écrire la référence de l’instance dans la case :
polygone[0] = new Point(2, 3);

Les bases du langage java : Chaine de caractères
Le type String (chaîne) sert a représenter des séquences de
caractère.
Les chaînes de caractères sont des instances de la classe String.
Une chaîne constante est délimité par des guillemets.
132
String est une classe qui est fourni avec l’API Java, elle décrit
des objets qui contiennent une chaîne de caractère constante et
permet un traitement très riches des chaînes de caractères.
Elle dispose des opérateurs + ou += pour concaténation des
chaînes de caractères.
String messageEtudiant = "Java est facile" ;

133

Quelques Constructeurs de la classe String :
Constructor Summary
String()
Initializes a newly created String object so that it represents an empty character sequence.
String(byte[] bytes)
Constructs a new String by decoding the specified array of bytes using the platform's default charset.
String(byte[] bytes, Charset charset)
Constructs a new String by decoding the specified array of bytes using the specified charset.
String(byte[] ascii, int hibyte)
134
String(byte[] ascii, int hibyte)
Deprecated. This method does not properly convert bytes into characters. As of JDK 1.1, the
preferred way to do this is via the String constructors that take a Charset, charset name, or that use the
platform's default charset.
String(byte[] bytes, int offset, int length)
Constructs a new String by decoding the specified subarray of bytes using the platform's default
charset.
String(byte[] bytes, int offset, int length, Charset charset)
Constructs a new String by decoding the specified subarray of bytes using the specified charset.
String(byte[] ascii, int hibyte, int offset, int count)
Deprecated. This method does not properly convert bytes into characters. As of JDK 1.1, the
preferred way to do this is via the String constructors that take a Charset, charset name, or that use the
platform's default charset.

Quelques méthodes de la classe String :
Method Summary
charcharAt(int index)
Returns the char value at the specified index.
intcompareTo(String anotherString)
Compares two strings lexicographically.
intcompareToIgnoreCase(String str)
Compares two strings lexicographically, ignoring case differences.
booleancontains(CharSequence s)
Returns true if and only if this string contains the specified sequence of char values.
booleanendsWith(String suffix)
135
booleanendsWith(String suffix)
Tests if this string ends with the specified suffix.
booleanequalsIgnoreCase(String anotherString)
Compares this String to another String, ignoring case considerations.
inthashCode()
Returns a hash code for this string.
intindexOf(int ch)
Returns the index within this string of the first occurrence of the specified character.
intindexOf(int ch, int fromIndex)
Returns the index within this string of the first occurrence of the specified character, starting the search at
the specified index.
intlength()
Returns the length of this string.
String[]split(String regex)
Splits this string around matches of the given regular expression.

Quelques méthodes de la classe String :
Method Summary
StringtoLowerCase()
Converts all of the characters in this String to lower case using the rules of the default locale.
String replaceAll(String regex, String replacement)
Replaces each substring of this string that matches the given regular expression with the given replacement.
String replaceFirst(String regex, String replacement)
Replaces the first substring of this string that matches the given regular expression with the given replacement.
boolean startsWith(String prefix)
Tests if this string starts with the specified prefix.
boolean startsWith(String prefix, int toffset)
136
boolean startsWith(String prefix, int toffset)
Tests if the substring of this string beginning at the specified index starts with the specified prefix.
String substring(int beginIndex)
Returns a new string that is a substring of this string.
String toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.
String toUpperCase(Locale locale)
Converts all of the characters in this String to upper case using the rules of the given Locale.
static String valueOf(boolean b)
Returns the string representation of the boolean argument.
String replaceAll(String regex, String replacement)
Replaces each substring of this string that matches the given regular expression with the given replacement.
String replaceFirst(String regex, String replacement)
Replaces the first substring of this string that matches the given regular expression with the given replacement.

Les Chaînes modifiables « StringBuffer »
Elles sont modifiables par insertion, ajouts, conversions, etc.
Il faut tout d'abord créé un objet instance de la classe
StringBuffer.
public class TestStringBuffer {
StringBuffer stringBuffer=new StringBuffer();
137
StringBuffer stringBuffer=new StringBuffer();
stringBuffer.append("J'ai eu ");
stringBuffer.append(15);
stringBuffer.append(" dans le DS Java");
System.out.println(stringBuffer);
stringBuffer.insert(0, "Salutn");
System.out.println(stringBuffer);
System.out.println(stringBuffer.capacity());
}
}

Les Chaînes modifiables « StringBuffer »
String msg= "toto";
msg += "encore toto";
instancie une chaîne msg avec toto, puis une autre chaîne qui
est la concaténation de msg et de "encore toto". Cette dernière
chaîne étant ensuite affectée a msg. Donc si on fait beaucoup de
concaténation, on instancie beaucoup de chaînes et ça prend du
138
concaténation, on instancie beaucoup de chaînes et ça prend du
temps.
StringBuffer sb = "toto";
sb.append("encore toto");
String msg=sb.toString();
produira le même résultat que précédemment mais diminuera le
nombre d'instanciations. Ce qui est d'autant plus vrai que l'on
effectue beaucoup de concaténations.

Les Chaînes modifiables « StringTokenizer »
Cette classe utilitaire permet de décomposer une chaîne en
plusieurs chaînes à partir d'un délimiteur.
Constructor Summary
StringTokenizer(String str)
Constructs a string tokenizer for the specified string.
139
StringTokenizer(String str, String delim)
StringTokenizer(String str, String delim, boolean returnDelims)

Method Summary
intcountTokens()
Calculates the number of times that this tokenizer's nextToken method
can be called before it generates an exception.
booleanhasMoreElements()
Returns the same value as the hasMoreTokens method.
140
Returns the same value as the hasMoreTokens method.
booleanhasMoreTokens()
Tests if there are more tokens available from this tokenizer's string.
ObjectnextElement()
Returns the same value as the nextToken method, except that its
declared return value is Object rather than String.
StringnextToken()
Returns the next token from this string tokenizer.
StringnextToken(String delim)
Returns the next token in this string tokenizer's string.

141

142

Les bases du langage java : Wrapper
À chaque type primitif est associé une classe qu’on appelle
classe enveloppe (wrapper) de ce type primitif.
La classe enveloppe du type int est la classe Integer.
Integer integer2=new Integer(12);
De plus, chaque classe enveloppe d’un type primitif possède
143
De plus, chaque classe enveloppe d’un type primitif possède
une méthode pour convertir une instance de la classe en une
valeur du type primitif associé.
int b=integer2.intValue();

Pour les autres types primitifs, les noms des classes enveloppes
sont :
144

Pour chaque classe enveloppe, il existe plusieurs
constructeurs qui permettent de faire des conversions
explicites depuis les différents types primitifs ou depuis une
chaîne de caractère.
Integer integer1=new Integer("10");
145
Ces classes enveloppe permettent aussi de convertir, grâce à
des méthodes de classe, une chaîne de caractères en types
primitifs (int, float, boolean, etc.).
int indice =Integer.parseInt("9") ;
double moyenne = Double.parseDouble("6.89") ;
boolean trouve = Boolean.parseBoolean("false");

Integer integer1 = new Integer("10");
La version 5.0 de Java introduit un mécanisme d’autoboxing
(mise en boîte) qui automatise le passage des types primitifs
vers les classes enveloppe. L’opération inverse s’appelle
unboxing.
146
Integer integer1 = new Integer("10");
Integer integer2 = new Integer(12);
Integer integer3 = 5;
int a=integer1.intValue();
int b=integer2.intValue();
System.out.println("a ="+a+" b="+b);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.toBinaryString(1025));
}

Plan
Concept Object
147
Les exceptions

Héritage
Principe : Réutilisation par extension
Une classe représentant un concept voisin d’une classe existante n’a
pas besoin d’être définie à partir de rien.
L'héritage est une technique qui permet d'utiliser une (ou plusieurs)
classe existante (classe de base) pour en créer une nouvelle, dite
classe dérivée.
Créer la classe Etudiant à partir de la classe Personne.
148
Créer la classe Etudiant à partir de la classe Personne.
Créer la classe Voiture à partir de la classe Vehicule.
La nouvelle classe hérite naturellement des membres (attributs et
méthodes) de la classe de base qu'elle pourra modifier ou
compléter, sans toucher à la classe de base.
Une classe dérivée pourra à son tour servir de classe de base pour
une nouvelle classe dérivée.

Héritage
La classe de base est encore appelée : super-classe ou classe
parente.
La classe dérivée est appelée sous-classe ou classe fille.
L'objectif est de créer des classes de plus en plus précises, héritant
des caractéristiques de classes plus générales.
149

Héritage
Une classe dérivée pourra à son tour servir de classe de base pour
une nouvelle classe dérivée.
150

Héritage
Ce que peut faire une classe fille ?
La classe qui hérite peut :
−ajouter des attributs, des méthodes et des constructeurs
−redéfinir des méthodes (exactement les mêmes types de
paramètres)
151
paramètres)
−surcharger des méthodes (même nom mais pas même signature)
(possible aussi à l’intérieur d’une classe)

Héritage
Un objet de la classe Etudiant ou Enseignant est forcément
un objet de la classe Personne, il dispose donc de tous les
membres de la classe Personne.
Par contre, un objet de la classe Personne n'est pas
forcément un objet de la classe Etudiant ou Enseignant
152

Héritage
1. Spécialisation : La nouvelle classe réutilise une classe
existante en y ajoutant des attributs et/ou des méthodes
supplémentaires. Par exemple on réutilise la classe Employer
pour créer la classe Commerciale en y ajoutant une méthode
prime().
2. Redéfinition : La nouvelle classe redéfinit les attributs et/ou
153
2. Redéfinition : La nouvelle classe redéfinit les attributs et/ou
les méthodes d'une classe existante de manière à en changer
le sens ou le comportement. Par exemple on réutilise la
classe Vehicule pour créer la classe Voiture, mais, en
redéfinissant la méthode avancer().
3. Réutilisation de code : Réutiliser du code existant, même si
on ne possède pas les sources de la classe de base.

Héritage
L'héritage supprime, en grande partie, les redondances dans le
code.
Une fois la hiérarchie de classes bien établie, on peut localiser en
un point unique les sections de code (celles-ci restantes à tous
moments accessibles grâce au mot clé super).
154
Si la hiérarchie des classes est bien pensée, on peut très facilement
rajouter une classe, dans la mesure où on peut réutiliser le code des
classes parentes.
Si vous n'aviez pas encore modélisé un comportement dans une
classe donnée, et que vous vouliez maintenant le rajouter, une fois
l'opération terminée, ce comportement sera alors directement
utilisable dans l'ensemble des sous-classes de celle considérée.

Héritage
En Java, une classe de base peut avoir plusieurs classes
dérivées, mais une classe dérivée ne peut hériter que d’une
seule classe de base : on parle d’héritage simple.
Java ne propose donc pas l’héritage multiple qui permet à une
classe dérivée d’hériter de plusieurs classes quelconques.
155
On peut cependant partiellement contourner le problème grâce
à la notion d’Interface : Java permet à une classe dérivée qui
hérite déjà d’une classe de base d’hériter d’une ou plusieurs
classes particulières appelées Interfaces.

Héritage
En java, on utilise le mot clé extends pour spécifier la classe dont
on hérite.
public class Oeuvre {
String titre = null;
int annee ;
public void reduireStock(){}
}
156
}
public class Livre extends Oeuvre
{
String isbn = null;
}
public class Disque extends Oeuvre
{
int duree;
}

Héritage
En java, on utilise le mot clé extends pour spécifier la classe dont
on hérite.
public class Personne {
private String nom = null;
private String prenom = null;
private byte age = 0;
}
public class Employer extends Personne
{
157
{
private String societe = null;
protected float salaire = 0;
public double prime(){
return salaire * 0.1;
}
}
public class Cadre extends Employer
{
public double prime() {
}
}

Héritage
Toutes classes java dérivent, par défaut, de la classe
java.lang.Object.
Method Summary
protected Objectclone()
Creates and returns a copy of this object.
booleanequals(Object obj)
158
Indicates whether some other object is "equal to" this
one.
protected voidfinalize()
Called by the garbage collector on an object when
garbage collection determines that there are no more
references to the object.
Class<?>getClass()
Returns the runtime class of this Object.
inthashCode()
Returns a hash code value for the object.

Héritage
Toutes classes java dérivent, par défaut, de la classe
java.lang.Object.
Method Summary
voidnotify()
Wakes up a single thread that is waiting on this object's monitor.
voidnotifyAll()
Wakes up all threads that are waiting on this object's monitor.
StringtoString()
159
StringtoString()
Returns a string representation of the object.
voidwait()
Causes the current thread to wait until another thread invokes the notify() method or
the notifyAll() method for this object.
voidwait(long timeout)
Causes the current thread to wait until either another thread invokes the notify()
method or the notifyAll() method for this object, or a specified amount of time has
elapsed.
voidwait(long timeout, int nanos)
Causes the current thread to wait until another thread invokes the notify() method or
the notifyAll() method for this object, or some other thread interrupts the current thread,
or a certain amount of real time has elapsed.

Héritage : Constructeur
Une classe n'hérite pas des constructeurs de la classe mère. Il faut
toujours définir tous les constructeurs dont elle a besoin, même si ces
derniers ne font que des appels aux constructeurs de la classe mère par
super (arguments).
En Java, il est obligatoire dans un constructeur d'une classe fille de
faire appel explicitement ou implicitement au constructeur de la
classe mère.
160
classe mère.
N.B. L'appel au constructeur de la classe mère doit se faire absolument
en première instruction.
Attention: quand il n'existe pas d'appel explicite d'un constructeur de
la classe mère, le compilateur ajoute un appel implicite au constructeur
sans paramètre (super()) de la classe mère (erreur s’il n’existe pas).
Un constructeur de la classe mère est toujours exécuté avant les autres
instructions du constructeur.

public class Personne {
private String nom = null;
private String prenom = null;
private byte age = 0;
public Personne(String nom, String prenom, byte age) {
this.nom = nom;
this.prenom = prenom;
this.age = age;
}
public Personne() {
this(null, null, (byte) 0);
161
this(null, null, (byte) 0);
}
}
public class Employe extends Personne {
public Employe(String nom, String prenom, String societe, float salaire, byte age) {
super(nom, prenom, age);
this.societe = societe;
this.salaire = salaire;
}
public Employe() {
this(null, null, null, 0, (byte) 0);
}
}

public class Rectangle {
private int x; private int y; private int width; private int height;
public Rectangle(int x, int y, int width, int height) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
}
}
162
import java.awt.Color;
public class RectangleWithColor extends Rectangle {
Color color = null;
public RectangleWithColor(int x, int y, int width, int height, Color color) {
super(x, y, width, height);
this.color=color;
}
public RectangleWithColor(int x, int y, int width, int height) {
this(x, y, width, height, Color.black);
}
}

import java.awt.Color;
Color color = null;
this.color=color;
}
163
}
}

public class Vehicule {
}
class Voiture extends Vehicule {
int nbPortes;
double longueur;
Voiture(double longueur, int nbPortes) {
super();
// appel implicite de Vehicule(), sans paramètres
this.longueur = longueur;
164
this.longueur = longueur;
this.nbPortes = nbPortes;
}
}

La première instruction qui est exécutée par un constructeur
est le constructeur (sans paramètre) par défaut de la classe
Object. (D’ailleurs c’est le seul qui sait comment créer un
nouvel objet en mémoire)
public class Cercle {
// Constante
public static final double PI = 3.14;
165
public static final double PI = 3.14;
// Attributs
private Point centre;
private int rayon;
// Constructeur
public Cercle(Point centre, int rayon) {
// Appel implicite du constructeur Object()
this.centre = centre;
this.rayon = rayon;
}
}

Héritage : redéfinition & surcharge
On appelle surcharge (en anglais « overloading ») d’un
membre, la possibilité de définir des comportements différents
pour le même membre selon les arguments passés en paramètres.
Dans ce cas, deux membres d’une même classe peuvent porter le
même nom mais n’ont pas la même signature.
Il ne faut pas confondre la surcharge (en anglais « overloading »)
166
Il ne faut pas confondre la surcharge (en anglais « overloading »)
et la redéfinition (en anglais « overriding ») (qui sera étudiée
dans le cours sur le polymorphisme) qui correspond à la
possibilité de spécifier le comportement d’une méthode à
l’exécution selon le type d’objets l’invoquant.

La redéfinition d'une méthode « écrase » le code de la
méthode héritée. Il est cependant possible de réutiliser le code
de la méthode héritée grâce au mot clé super.
super permet de désigner explicitement l'instance d'une classe
dont le type est celui de la classe mère.
167
Par exemple, dans la classe Employe (sous classe de
Personne), super permet de désigner explicitement une
instance de la classe Personne.
super permet donc l'accès aux attributs et méthodes redéfinies
par la classe courante mais que l'on souhaite utiliser

public class Employe extends Personne
{
}
168
}
}
public class Cadre extends Employe
{
public double prime()
{
}
}
Redéfinition de la méthode
prime de la classe Employe.
Spécialisation de la méthode
existante.

public class Employer extends Personne{
}
}
public class Cadre extends Employe{
169
public class Cadre extends Employe{
public double prime()
{
}
public double prime(float coef)
{
return salaire * coef;
}
}
Surcharge de la méthode
prime de la classe Cadre

Héritage : super
class Employe extends Personne
{
}
}
170
}
class Cadre extends Employe
{
public double prime() {
return super.prime()+ (salaire * 0.4);
}
public double prime(float coef)
{
return salaire * coef;
}
}

Héritage : super
public class Capitale extends Ville {
private String monument;
// Constructeur par défaut
public Capitale() {
// Ce mot clé appelle le constructeur de la classe mère
super();
monument = "aucun";
171
monument = "aucun";
}
public String toString() {
return super.toString() + "n t ==>>" + this.monument
+ " en est un monument";
}
}

Héritage : accès
Accès d'une classe dérivée aux membres de sa classe de base)
Une méthode d'une classe dérivée n'accède pas aux membres
(attributs et méthodes) privés de sa classe de base.
Une classe dérivée (un objet d'une classe dérivée) n'accède
pas aux membres privés de sa classe de base.
172
pas aux membres privés de sa classe de base.
Un objet d’une classe fille n’a accès que pour les membres
déclaré public ou protected de sa classe mère.

Héritage : final
Comment interdire l'héritage?
Utilisation du mot-clé final devant une méthode
Le mot-clé final devant une méthode permet d'interdire une
éventuelle redéfinition de la méthode.
Exemple :
public final double prime(){return salaire * 0.1;}
173
public final double prime(){return salaire * 0.1;}
Utilisation du mot-clé final devant une classe
Le mot-clé final devant une classe permet d'interdire toute
spécialisation ou héritage de la classe.
Exemple :
public final class Employe extends Personne {}
Autre exemple : la classe String est finale

Utilisation de « super » et masquage des données :
class A
{
int x;
void m( ) {...}
}
class B extends A
{
int y;
void m( ) {...}
}
Héritage : masquage de données
174
class C extends B
{
int a;
a = super.y; // a reçoit la valeur de la variable y de la classe B
a = super.super.x; // erreur syntaxique
a = ((B) this).y; // a reçoit la valeur de la variable y de la classe B
a = ((A) this).x; // a reçoit la valeur de la variable x de la classe A
super.m( ); // Appel à la méthode m de la classe B
}

Héritage : erreur de débutant
private int x;
private int y;
private int width;
private int height;
Color color = null;
175
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.color=color;
}
}
}

Héritage : Classes et méthodes abstraites
Le mécanisme des classes abstraites permet de définir des
comportements (méthodes) qui devront être implémentés dans
les classes filles, mais sans implémenter ces comportements
(c’est-à-dire sans écrire de code pour cette méthode)
Ainsi, on a l'assurance que les classes filles respecteront le
176
Ainsi, on a l'assurance que les classes filles respecteront le
contrat défini par la classe mère abstraite
Ce contrat est une interface de programmation
Une classe abstraite sert à mettre en facteur des attributs et
des méthodes pour des classes dérivées concrètes.

Une classe abstraite est introduite par le mot clé « abstract »
Une méthode abstraite est déclaré par le mot clé abstract, elle n’a
pas de corps.
Une classe abstraite ne peut pas être instanciée (new).
Si une classe dérivée d’une classe abstraite ne redéfinie pas toute les
177
Si une classe dérivée d’une classe abstraite ne redéfinie pas toute les
méthodes abstraites alors elle doit être déclarée abstraite.
Pour utiliser un classe abstraite on doit définir une classe héritière
qui fournit les réalisations des méthodes abstraites de la classe
abstraite.

public abstract class Animal {
}
public abstract void manger();
}
178
private abstract void manger();
}
public abstract void manger(int);
}

Une méthode abstraite n'est composée que de l'en-tête de la méthode
suivie d'un point-virgule « ; »
Une méthode abstraite ne peut exister que dans une classe abstraite.
Si, dans une classe, vous avez une méthode déclarée abstraite, vous
devez déclarer cette classe comme étant abstraite
179
devez déclarer cette classe comme étant abstraite
Une méthode abstraite doit obligatoirement être déclarée public ou
protected, ce qui est logique car sa vocation est d’être redéfinie dans
une classe dérivée
Dans l’entête d’une méthode abstraite, il faut mentionner les nom
des arguments muets

Une classe dérivée d’une classe abstraite n’a pas besoin de redéfinir
toutes les méthodes abstraite de sa classe
Une classe dérivée d’une classe non abstraite peut être déclarée
abstraite et/ou contenir des méthodes abstraites
180

Le recours aux classes abstraites facilite la conception orientée objet
On peut placer dans une classe abstraite toutes les fonctionnalités
dont on souhaite disposer pour toutes ses descendances :
Intérêt des classes abstraites
181
− Soit sous forme d’une implémentation complète de méthodes (non
abstraites) et de champs (privés ou non) lorsqu’ils sont communs à
toutes ses descendances
− Soit sous forme d’interface de méthodes abstraites dont on est alors
sûr qu’elles existeront dans toute classe dérivée instanciable

protected String couleur;
protected int poids;
protected void manger() {
System.out.println("Je mange de la viande.");
}
protected void boire() {
System.out.println("Je bois de l'eau !");
182
System.out.println("Je bois de l'eau !");
}
public abstract void deplacement();
public abstract void crier();
public String toString() {
String str = "Je suis un objet de la " + this.getClass() + ", je suis "
+ this.couleur + ", je pèse " + this.poids;
return str;
}
}

public abstract class Felin extends Animal {
public void deplacement() {
System.out.println("Je me déplace seul !");
}
}
183
public abstract class Canin extends Animal {
public void deplacement() {
System.out.println("Je me déplace en meute !");
}
}

public class Lion extends Felin {
public Lion() {
}
public Lion(String couleur, int poids) {
this.couleur = couleur;
this.poids = poids;
}
public void crier() {
System.out.println("Je rugis dans la savane !");
}
184
public class Loup extends Canin {
public Loup() {
}
public Loup(String couleur, int poids) {
this.couleur = couleur;
this.poids = poids;
}
public void crier() {
System.out.println("Je hurle à la Lune en faisant ouhouh !");
}
}
}
}

Un paquetage ou package sert à regrouper un ensemble de classes sous un même nom.
Il joue le rôle d'une bibliothèque regroupant plusieurs classes.
Parmi les avantages du paquetage, on peut citer :
Ils permettent de créer une structure de classes selon une arborescence. Ex. un
paquetage peut contenir lui-même d'autres paquetages, et ces paquetages
contiennent des classes.
Ils permettent de gérer les accès aux classes : une classe A appartenant au même
paquetage qu'une classe B peut utiliser cette classe sans que cette classe soit
déclarée public.
Les paquetages (package)
185
déclarée public.
Un nom d'un paquetage est soumis aux mêmes règles que les noms de classes ou les
noms de fonctions. Si un paquetage est inclus dans un autre paquetage, cette
arborescence doit apparaître dans le nom du paquetage.
Pour signaler qu'une classe appartient à un paquetage epi.formation, il faut mettre au
début du fichier source contenant celle-ci, la ligne suivante :
package epi.formation;
La création d'un paquetage nommé par exemple formation est généralement
matérialisée par la création physique sur le disque dur d'un répertoire nommée
formation.

Java 2015 2016_zied_elleuch

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Java 2015 2016_zied_elleuch

Ähnlich wie Java 2015 2016_zied_elleuch (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (18)

Java 2015 2016_zied_elleuch