Programmation Orientée Objet – Java Les tableaux Les tableaux

Transcription

Java
Classes et instances
Les tableaux
Déclaration d’une variable de type “référence vers un tableau” :
int[] arrayOfInt;
double[] arrayOfDouble;
Programmation Orientée Objet – Java
Allocation d’un tableau :
Bertrand Estellon
arrayOfInt = new int[10];
arrayOfDouble = new double[3];
Département Informatique et Interactions
Aix-Marseille Université
Utilisation d’un tableau :
21 septembre 2016
arrayOfInt[0] = 5;
arrayOfInt[9] = 10;
arrayOfInt[2] = arrayOfInt[0] + 3*arrayOfInt[9];
arrayOfDouble[2] = arrayOfInt[2] + 3.5;
Bertrand Estellon (DII – AMU)
Java
21 septembre 2016
1 / 171
Java
Les tableaux
Références et Garbage Collector
L’expression new int[10] retourne une “référence vers un tableau” :
Une variable de type “référence” peut valoir null :
int[] array = new int[10];
int[] array2 = array;
// Allocation d'un tableau
// Copie de la référence
21 septembre 2016
28 / 171
int[] array = null;
// La variable "array" contient la référence "null".
// Elle pointe vers aucune instance.
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"
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 :
Taille du tableau :
int[] array = new int[10];
array[3] = 6;
...
array = null;
// La mémoire utilisée pour le tableau peut être libérée
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);
21 septembre 2016
29 / 171
21 septembre 2016
30 / 171
Java
Java
Des tableaux aux objets
Les objets
Un objet :
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 :
▶
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 :
▶
affecter une valeur à une case : array[index] = value ;
▶
une façon de construire des objets (constructeur)
▶
consulter la valeur d’une case : array[index] ;
▶
la structure des objets de la classe (propriétés)
▶
récupérer sa longueur : array.length ;
▶
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”
Les types “référence vers des tableaux” sont définis dans le langage
Java
21 septembre 2016
31 / 171
Java
21 septembre 2016
Les propriétés
Le mot clé class permet de définir une classe :
Les propriétés décrivent la structure de données de la classe :
class Counter { int position; int step; }
class Counter {
/* Définition des propriétés et des méthodes */
}
On accède aux propriétés avec l’opérateur “.” (point) :
On peut ensuite définir une variable de type “référence vers un Counter” :
Counter counter;
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 la
classe Counter.
21 septembre 2016
counter.position = 12; counter.step = 2;
counter.position += counter.step;
Chaque instance possède son propre état :
Une classe définit également un “moule” pour fabriquer des objets.
32 / 171
33 / 171
Counter counter1 = new Counter();
counter1.position = 10; counter2.position = 20;
if (counter1.position!=counter2.position)
System.out.println("différent");
21 septembre 2016
34 / 171
Java
Java
Références et Garbage Collector
Les méthodes
Méthodes qui modifient l’objet :
Comme pour les tableaux, on peut copier les références :
class Counter {
int position, step;
Counter counter2 = counter1;
counter1.position = 10;
if (counter1.position==counter2.position)
System.out.println("égalité");
void init(int initPos, int s) {
position = initPos; step = s;
}
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
Java
21 septembre 2016
void count() { position += step; }
}
On invoque les méthodes avec l’opérateur “.” (point) :
counter.init(4, 8+12); counter.count(); counter.count();
System.out.println(counter.position);
35 / 171
Java
Les méthodes
Les méthodes
Méthode permettant de consulter l’état de l’objet :
Méthode qui modifie et retourne une valeur :
36 / 171
class Counter {
class Counter {
/* Code de la méthode init. */
/* Code du slide précédent. */
int count() { position += step; return position; }
int getPosition() { return position; }
}
}
Exemple d’utilisation :
counter.init(4, 8+12); counter.count(); counter.count();
System.out.println(counter.getPosition());
21 septembre 2016
21 septembre 2016
37 / 171
counter.init(4, 8+12);
System.out.println(counter.count());
System.out.println(counter.count());
21 septembre 2016
38 / 171
Java
Java
Comparaison de références
Déclaration d’un constructeur
Il est possible de comparer deux références :
Les constructeurs permettent d’agréger l’allocation et l’initialisation :
class Counter {
int position, step;
public class Test {
public static void main(String arg[]) {
Counter counter2 = counter1;
Counter(int p, int s) { position = p; step = s; }
Counter(int p) { position = p; step = 1; }
if (counter1==counter2) System.out.println("==");
/* Méthodes count() et getPosition() */
}
if (counter1!=counter3) System.out.println("!=");
if (counter2!=counter3) System.out.println("!=");
}
Counter c1 = new Counter(2,10);
Counter c2 = new Counter(22);
}
Java
21 septembre 2016
39 / 171
Java
21 septembre 2016
40 / 171
Constructeur par défaut
Le mot-clé this
Si aucun constructeur n’est défini, la classe a un constructeur par défaut :
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 :
public class Counter {
int position = 10, step = 1;
}
class Counter {
int position, step;
Counter(int position, int step) {
this.position = position; this.step = step;
}
Ce code est équivalent à celui-ci :
public class Counter {
int position, step;
void count() {
int position = this.position;
position += step; this.position = position;
}
}
public Counter() {
position = 10; step = 1;
}
}
21 septembre 2016
41 / 171
21 septembre 2016
42 / 171
Java
Java
Le mot-clé this
Surcharge de méthode
Le mot-clé this permet également d’appeler un constructeur dans un
constructeur de façon à ne dupliquer du code :
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;
class Counter {
int position, step;
void set()
{ value = 0; }
void set(int value)
{ this.value = value; }
void set(double vallue) { this.value = (int)value; }
Counter(int position, int step) {
this.position = position; this.step = step;
}
}
Counter(int position) {
this(position, 1);
}
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
/* Autres méthodes. */
}
Java
21 septembre 2016
43 / 171
Java
21 septembre 2016
44 / 171
Propriétés et méthodes statiques
Données 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 :
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
Counter.setStep(4); counter1.count(); counter2.count();
}
}
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; }
}
21 septembre 2016
45 / 171
21 septembre 2016
46 / 171
Java
Java
Données et méthodes statiques
Chaînes de caractères
Une méthode statique ne peut utiliser que :
Trois classes permettent de gérer les chaînes de caractères :
▶
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.
Java
la classe StringBuffer : chaîne modifiable (multi-thread).
▶
la classe StringBuilder : chaîne modifiable (mono-thread).
Concaténation :
String helloWorld = hello + " "+ world + " ! ";
int integer = 13;
String helloWorld1213 = hello + " " + world
+ " " + 12 + " " + integer;
21 septembre 2016
47 / 171
Java
Chaînes de caractères
21 septembre 2016
48 / 171
21 septembre 2016
50 / 171
Point d’entrée et arguments
Le programme Echo.java :
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"
▶
String hello = "Hello";
String world = "World";
class Counter {
/* ... */
static void setStep(int step) {
Counter.step = step;
}
/* ... */
}
la classe String : chaîne invariable (immutable) ;
Déclaration et création :
L’utilisation de this n’a aucun sens dans une méthode statique :
▶
21 septembre 2016
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
$ ls
Echo.java Echo.class
$ java Echo toto aaa
toto
aaa
49 / 171
Java
Java
Programmer “proprement” : nommage
Programmer “proprement” : nommage
Un nommage correct des méthodes et variables améliore grandement la
lisibilité et la maintenabilité d’un code.
Êtes-vous capable de dire rapidement ce que fait cette classe ?
Le 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++;
}
class Structure {
private int s[] = new int[100];
private int t = 0;
public int pop() {
size--; return stack[size];
}
public void end(int i) { s[t] = i; t++; }
public int top() { t--; return s[t]; }
public bool isEmpty() {
return size == 0;
}
public bool test() { return t == 0; }
}
}
Java
21 septembre 2016
51 / 171
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]; }
}
21 septembre 2016
53 / 171
21 septembre 2016
52 / 171

Programmation Orientée Objet – Java Les tableaux Les tableaux

Transcription

Documents pareils

Introduction à la version 2 du code de bonnes pratiques Counter

lettre pour partenariat

Conception et développement Java/J2EE web

Ingénieur Informatique Java-J2EE (HF) Conception et

Projet Gestion d`Utilisateurs en Java

Diplomatic-Cover - Top Interactive Agencies

Procédure d`installation et d`activation de licence : Télécharger la

CV.ROUVIER.F-Info - IUT de Villetaneuse

CDI JAVA / J2EE Confirmé