pdf/4

Programmation Orientée Objet – Java
Bertrand Estellon
Département Informatique et Interactions
Aix-Marseille Université
21 septembre 2016
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 1 / 171
Java Classes et instances
Les tableaux
Déclaration d’une variable de type “référence vers un tableau” :
int[] arrayOfInt;
double[] arrayOfDouble;
Allocation d’un tableau :
arrayOfInt =new int[10];
arrayOfDouble =new double[3];
Utilisation d’un tableau :
arrayOfInt[0] = 5;
arrayOfInt[9] = 10;
arrayOfInt[2] = arrayOfInt[0] + 3*arrayOfInt[9];
arrayOfDouble[2] = arrayOfInt[2] + 3.5;
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 28 / 171
Java Classes et instances
Les tableaux
L’expression new int[10] retourne une “référence vers un tableau” :
int[] array =new int[10]; // Allocation d'un tableau
int[] array2 =array;// Copie de la référence
Seule la référence est copiée, il n’y a qu’un seul tableau :
array[4] = 2; // Affectation d'une valeur à la 5ème case
System.out.println(array2[4]); // "5"
Taille du tableau :
int[] array =new int[10]; // Allocation d'un tableau
int length =array.length;// Récupération de la taille
System.out.println(length);
/* ou directement */ System.out.println(array.length);
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 29 / 171
Java Classes et instances
Références et Garbage Collector
Une variable de type “référence” peut valoir null :
int[] array =null;
// La variable "array" contient la référence "null".
// Elle pointe vers aucune instance.
Important : Une référence contient soit null soit la référence d’un
tableau ou d’un objet compatible avec le type de la variable.
Le Garbage collector peut supprimer les éléments devenus innaccessibles :
int[] array =new int[10];
array[3] = 6;
...
array =null;
// La mémoire utilisée pour le tableau peut être libérée
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 30 / 171

Java Classes et instances
Des tableaux aux objets
Un tableau :
▶peut être alloué (ou construit) : array = new int[5]
▶est structuré : il est constitué d’un ensemble de cases
▶possède un état : la valeur de ses cases
▶possède une interface
L’interface d’un tableau :
▶aecter une valeur à une case : array[index] = value ;
▶consulter la valeur d’une case : array[index] ;
▶récupérer sa longueur : array.length ;
Les types “référence vers des tableaux” sont dénis dans le langage
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 31 / 171
Java Classes et instances
Les objets
Un objet :
▶peut être construit
▶est structuré : il est constitué d’un ensemble de propriétés
▶possède un état : la valeur de ses propriétés
▶possède une interface : l’ensemble des méthodes et propriétés
accessibles par les utilisateurs de l’objet
Dans les langages orientés objet, une classe (d’objets) dénit :
▶une façon de construire des objets (constructeur)
▶la structure des objets de la classe (propriétés)
▶le comportement des objets de la classe (méthodes)
▶l’interface des objets de la classe (méth. et prop. non-privées)
▶un type “référence vers des objets de cette classe”
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 32 / 171
Java Classes et instances
Classes et instances
Le mot clé class permet de dénir une classe :
class Counter {
/* Définition des propriétés et des méthodes */
}
On peut ensuite dénir une variable de type “référence vers un Counter” :
Counter counter;
Une classe dénit également un “moule” pour fabriquer des objets.
La création d’une instance s’eectue avec le mot clé new :
Counter counter =new Counter();
La variable counter contient alors une référence vers une instance de la
classe Counter.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 33 / 171
Java Classes et instances
Les propriétés
Les propriétés décrivent la structure de données de la classe :
class Counter {int position;int step; }
On accède aux propriétés avec l’opérateur “.” (point) :
Counter counter =new Counter();
counter.position = 12; counter.step = 2;
counter.position += counter.step;
Chaque instance possède son propre état :
Counter counter1 =new Counter();
Counter counter2 =new Counter();
counter1.position = 10; counter2.position = 20;
if (counter1.position!=counter2.position)
System.out.println("différent");
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 34 / 171

Java Classes et instances
Références et Garbage Collector
Comme pour les tableaux, on peut copier les références :
Counter counter1 =new Counter();
Counter counter2 =counter1;
counter1.position = 10;
if (counter1.position==counter2.position)
System.out.println("égalité");
Important : Une référence contient soit null soit la référence d’un objet
compatible avec le type de la variable.
Le Garbage collector peut supprimer les objets devenus innaccessibles :
Counter c =new Counter(); ...; c=null;
// La mémoire utilisée pour l'objet peut être libérée
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 35 / 171
Java Classes et instances
Les méthodes
Méthodes qui modient l’objet :
class Counter {
int position,step;
void init(int initPos,int s) {
position =initPos;step =s;
}
void count() { position += step; }
}
On invoque les méthodes avec l’opérateur “.” (point) :
Counter counter =new Counter();
counter.init(4, 8+12); counter.count(); counter.count();
System.out.println(counter.position);
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 36 / 171
Java Classes et instances
Les méthodes
Méthode permettant de consulter l’état de l’objet :
class Counter {
/* Code du slide précédent. */
int getPosition() { return position; }
}
Exemple d’utilisation :
Counter counter =new Counter();
counter.init(4, 8+12); counter.count(); counter.count();
System.out.println(counter.getPosition());
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 37 / 171
Java Classes et instances
Les méthodes
Méthode qui modie et retourne une valeur :
class Counter {
/* Code de la méthode init. */
int count() { position += step;return position; }
}
Exemple d’utilisation :
Counter counter =new Counter();
counter.init(4, 8+12);
System.out.println(counter.count());
System.out.println(counter.count());
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 38 / 171

Java Classes et instances
Comparaison de références
Il est possible de comparer deux références :
public class Test {
public static void main(String arg[]) {
Counter counter1 =new Counter();
Counter counter2 =counter1;
if (counter1==counter2)System.out.println("==");
Counter counter3 =new Counter();
if (counter1!=counter3)System.out.println("!=");
if (counter2!=counter3)System.out.println("!=");
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 39 / 171
Java Classes et instances
Déclaration d’un constructeur
Les constructeurs permettent d’agréger l’allocation et l’initialisation :
class Counter {
int position,step;
Counter(int p,int s) { position =p;step =s; }
Counter(int p) { position =p;step = 1; }
/* Méthodes count() et getPosition() */
}
Exemple d’utilisation :
Counter c1 =new Counter(2,10);
Counter c2 =new Counter(22);
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 40 / 171
Java Classes et instances
Constructeur par défaut
Si aucun constructeur n’est déni, la classe a un constructeur par défaut :
public class Counter {
int position = 10, step = 1;
}
Ce code est équivalent à celui-ci :
public class Counter {
int position,step;
public Counter() {
position = 10; step = 1;
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 41 / 171
Java Classes et instances
Le mot-clé this
Le mot-clé this fait référence à l’instance en construction ou à l’instance
qui a permis d’invoquer la méthode en cours d’exécution :
class Counter {
int position,step;
Counter(int position,int step) {
this.position =position;this.step =step;
}
void count() {
int position =this.position;
position += step;this.position =position;
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 42 / 171

Java Classes et instances
Le mot-clé this
Le mot-clé this permet également d’appeler un constructeur dans un
constructeur de façon à ne dupliquer du code :
class Counter {
int position,step;
Counter(int position,int step) {
this.position =position;this.step =step;
}
Counter(int position) {
this(position, 1);
}
/* Autres méthodes. */
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 43 / 171
Java Classes et instances
Surcharge de méthode
Dans une classe, deux méthodes peuvent avoir le même nom. Java doit
pouvoir décider de la méthode à exécuter en fonction des paramètres :
class Value {
int value = 0;
void set() { value = 0; }
void set(int value) { this.value =value; }
void set(double vallue) { this.value = (int)value; }
}
Exemple d’utilisation :
Value value =new Value();
value.set(); // Première méthode
value.set(2); // Deuxième méthode
value.set(2.5); // Troisième méthode
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 44 / 171
Java Classes et instances
Propriétés et méthodes statiques
Les propriétés et des méthodes statiques sont directement associées à la
classe et non aux instances de la classe :
class Counter {
static int step;
int position;
Counter(int position) { this.position =position; }
static void setStep(int step) {
Counter.step =step;
}
void count() { position += step; }
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 45 / 171
Java Classes et instances
Données et méthodes statiques
Comme les propriétés et méthodes statiques sont associées à la classe, il
n’est pas nécessaire de posséder une instance pour les utiliser :
public class Test {
public static void main(String[] arg) {
Counter.setStep(3);
Counter counter1 =new Counter(2);
Counter counter2 =new Counter(3);
counter1.count(); counter2.count();
System.out.println(counter1.position); // →5
System.out.println(counter2.position); // →6
Counter.setStep(4); counter1.count(); counter2.count();
System.out.println(counter1.position); // →9
System.out.println(counter2.position); // →10
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 46 / 171