Programmation Orientée Objet – Java · 2015. 8. 27. · Java Classes et instances Les objets Un objet : peut être construit est structuré : il est constitué d’un ensemble

Programmation Orientée Objet – Java

Bertrand Estellon

Département Informatique et InteractionsAix-Marseille Université

12 novembre 2014

Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 12 novembre 2014 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 ;



Les tableauxL’expression new int[10] retourne une “référence vers un tableau” :

int[] array = new int[10]; // Allocation d'un tableauint[] 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 caseSystem.out.println(array2[4]); // "5"

Taille du tableau :int[] array = new int[10]; // Allocation d'un tableauint length = array.length ; // Récupération de la tailleSystem.out.println(length);/* ou directement */ System.out.println(array.length);



Références et Garbage CollectorUne 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’untableau 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



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 :▶ affecter 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éfinis dans le langage



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éfinit :▶ 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”



Classes et instancesLe mot clé class permet de définir une classe :

class Counter {/* Définition des propriétés et des méthodes */

}

On peut ensuite définir une variable de type “référence vers un Counter” :

Counter counter ;

Une classe définit également un “moule” pour fabriquer des objets.La création d’une instance s’effectue avec le mot clé new :Counter counter = new Counter();

La variable counter contient alors une référence vers une instance de laclasse Counter.



Les propriétésLes 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");



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 objetcompatible 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



Les méthodesMéthodes qui modifient 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);



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());



Les méthodes

Méthode qui modifie et retourne une valeur :

class Counter {

/* Code de la méthode init. */

int count() { position += step ; return position ; }}


Counter counter = new Counter();counter.init(4, 8+12);System.out.println(counter.count());System.out.println(counter.count());



Comparaison de référencesIl 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(" !=");

}}



Déclaration d’un constructeurLes 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() */}


Counter c1 = new Counter(2,10);Counter c2 = new Counter(22);



Constructeur par défaut

Si aucun constructeur n’est défini, 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 ;

}}



Le mot-clé thisLe mot-clé this fait référence à l’instance en construction ou à l’instancequi 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 ;

}}



Le mot-clé thisLe mot-clé this permet également d’appeler un constructeur dans unconstructeur 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. */}



Surcharge de méthodeDans une classe, deux méthodes peuvent avoir le même nom. Java doitpouvoir 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éthodevalue.set(2); // Deuxième méthodevalue.set(2.5); // Troisième méthode



Propriétés et méthodes statiques

Les propriétés et des méthodes statiques sont directement associées à laclasse 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 ; }}



Données et méthodes statiquesComme les propriétés et méthodes statiques sont associées à la classe, iln’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); // → 5System.out.println(counter2.position); // → 6Counter.setStep(4); counter1.count(); counter2.count();System.out.println(counter1.position); // → 9System.out.println(counter2.position); // → 10

}}



Données et méthodes statiques

Une méthode statique ne peut utiliser que :▶ des propriétés statiques à la classe ;▶ des méthodes statiques à la classe ;

afin de garantir par transitivité l’utilisation exclusive de données statiques.

L’utilisation de this n’a aucun sens dans une méthode statique :

class Counter {/* ... */static void setStep(int step) {

Counter.step = step ;}/* ... */

}



Chaînes de caractèresTrois classes permettent de gérer les chaînes de caractères :

▶ la classe String : chaîne invariable (immutable) ;▶ la classe StringBuffer : chaîne modifiable (multi-thread).▶ la classe StringBuilder : chaîne modifiable (mono-thread).

Déclaration et création :String hello = "Hello" ;String world = "World" ;

Concaténation :String helloWorld = hello + " "+ world + " ! " ;int integer = 13 ;String helloWorld1213 = hello + " " + world

+ " " + 12 + " " + integer ;



Chaînes de caractères

Affichage :

System.out.print(helloWorld); // affiche "Hello World !"System.out.println(helloWorld); // affiche "Hello World !"

// avec retour à la ligne

Comparaison :

String a1 = "a" ;String a2 = "a" ;String a3 = new String("a");System.out.println(a1==a2); // affiche "true"System.out.println(a1==a3); // affiche "false"System.out.println(a1.equals(a3)); // affiche "true"



Point d’entrée et argumentsLe programme Echo.java :

public class Echo {public static void main(String[] args) {

for (int i = 0 ; i < args.length ; i++)System.out.println(args[i]);

}}

$ javac Echo.java$ lsEcho.java Echo.class$ java Echo toto aaatotoaaa



Programmer “proprement” : nommage

Un nommage correct des méthodes et variables améliore grandement lalisibilité et la maintenabilité d’un code.

Êtes-vous capable de dire rapidement ce que fait cette classe ?

class Structure {private int s[] = new int[100];private int t = 0 ;

public void end(int i) { s[t] = i ; t++; }

public int top() { t-- ; return s[t]; }

public bool test() { return t == 0 ; }

}



Programmer “proprement” : nommageLe nommage des variables, attributs, classes et méthodes est important :

class Stack {private int stack[] = new int[100];private int size = 0 ;

public void push(int i) {stack[size] = i ; size++;

}

public int pop() {size-- ; return stack[size];

}

public bool isEmpty() {return size == 0 ;

}}



Conventions de nommage en Java

Conventions officielles de nommage en Java :▶ Première lettre en majuscule pour les noms des classes ;▶ Première lettre en minuscule pour les noms des membres ;▶ Premières lettres de chaque mot en majuscule ;▶ Noms simples et descriptifs ;▶ N’utiliser que des lettres et des chiffres.

class Stack {private int stack[] = new int[100];private int size = 0 ;

public void pushInteger(int i) { stack[size] = i ; size++; }public int popInteger() { size-- ; return stack[size]; }

}


Documents

Programmation Orientée Objet – Java · 2015. 8. 27. · Java Classes et instances Les objets Un objet : peut être construit est structuré : il est constitué d’un ensemble