2018/2019
[Link]
Notion de classe
Une classe est une extension de la notion de module. Les données et les
fonctions traitant les données sont réunies ensemble dans une classe qui
constitue un nouveau type.
La classe peut être vue comme un moule pour la création des objets, qu’on
les appelle des instances de la classe.
classe = attributs + mécanismes de création + méthodes
objet = valeurs des attributs + accès aux méthodes
Notion d’objet
Un objet est une instance(un exemplaire) construit dynamiquement sur le modèle
que décrit la classe.
Un objet a :
• une adresse en mémoire (identifie l’objet)
• un comportement (ou interface) : est donné par des fonctions ou procédures, appelées
méthodes
• un état interne : est donné par les valeurs de variables d’instances
objet = valeurs des attributs + accès aux méthodes
Déclaration d'une Classe
En Java, pour déclarer une classe on utilise le mot-clé class suivi du nom de la classe.
class Point {
...
}
La première lettre du nom d’une classe doit toujours être une lettre majuscule (ex : Point ).
Mélange de minuscule, majuscule avec la première lettre de chaque mot en majuscule
(ex : EnsembleDePoints).
Une classe se trouve dans un fichier portant son nom suivi l'extension .java (ex : [Link])
Déclaration d'une Classe
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.
Un membre dont la déclaration est précédée par le mot clé private n’est visible que dans
l’instance de la classe.
Il existe d’autres types de visibilité pour un membre que nous n’évoquerons pas dans l’immédiat
L’accès à un membre d’une classe se fait au moyen de l’opérateur « . ».
Déclaration d'une Classe
Une classe java contient trois grands types de membres :
public class Point {
//Attributs
private double x , y ;
// Constructeurs
public Point ( double x , double y ) { . . . }
// Méthodes
public double distanceAvec(Point p2 ) { . . . }
}
Constructeur
Un constructeur est une méthode particulière, qui n’a pas de type de retour, qui porte le même nom
que la classe. Il sera automatiquement appelée au moment de la création d’ objet.
Si une classe a plusieurs constructeurs, il s’agit de surcharge. Tous les constructeurs ont le même nom
de celui de la classe mais les types des paramètres différents.
Les constructeurs permettent aussi d’initialiser les attributs de la classe.
// Constructeurs
public Point ( double x , double y ) {
Le mot clé this est utilisé pour accéder aux attributs ou méthodes de l’objets.
Constructeur
Quelques règles:
Un constructeur ne fournit aucune valeur. Dans son en-tête, aucun type ne doit figurer devant
son nom. Même la présence de void est une erreur.
Une classe peut ne disposer d’aucun constructeur. On peut alors instancier des objets comme
s’il existait un constructeur par défaut sans arguments.
Un constructeur ne peut pas être appelé directement depuis une méthode.
Un constructeur peut appeler un autre constructeur de la même classe.
Création d'un objet
Pour créer une instance d’une classe, on utilise l’opérateur new avec l’un des
constructeurs de la classe : p = 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.
Création d'un objet
Pour créer une instance d’une classe, on utilise l’opérateur new avec l’un des
constructeurs de la classe : p = 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.
Affectation et comparaison d’objets
Supposons que nous disposions d’une classe Point possédant un constructeur à
deux arguments entiers et considérons ces instructions.
….
Point a , b ; Après leur exécution,
…. on aboutit à cette situation :
a = new Point ( 3, 5);
b = new Point ( 2, 0);
….
.
Affectation et comparaison d’objets
Exécutons maintenant l’affectation : a = b.
….
Point a , b ;
….
a = new Point ( 3, 5);
b = new Point ( 2, 0);
a = b;
….
.
Affectation et comparaison d’objets
Exécutons maintenant l’affectation : a = b.
….
Point a , b ;
….
a = new Point ( 3, 5);
b = new Point ( 2, 0);
a = b;
….
Donc, a et b désignent le même objet, et
non pas deux objets de même valeur
.
Affectation et comparaison d’objets
Quels résultats fournit ce programme ?
class Entier{
public Entier (int nn) { n = nn ; }
[Link] ("n1 = ") ;
public void incr (int dn) { n += dn ; }
[Link]() ;
public void imprime () { [Link] (n) ; }
[Link] ("n1 == n2 est " + (n1 == n2)) ;
private int n ;
n1 = n2 ; [Link](12) ;
public static void main (String args[]) {
[Link] ("n2 = ") ;
Entier n1 = new Entier (2) ;
[Link]() ;
[Link] ("n1 = ") ;
[Link] ("n1 = ") ;
[Link]() ;
[Link]() ;
Entier n2 = new Entier (5) ;
[Link] ("n1 == n2 est " + (n1 == n2)) ;
[Link] ("n2 = ") ;
}
[Link]() ;
}
[Link](3) ;
La notion de clone
L’affectation de variables de type objet se limite à la recopie de références. Elle ne provoque
pas la recopie de la valeur des objets.
Si on le souhaite, on peut bien entendu effectuer explicitement la recopie de tous les
champs d’un objet dans un autre objet de même type.
public Point copie() {
Point p = new Point ( , );
p
}
Cette démarche est utilisable tant que la classe concernée ne comporte pas de champs de type classe.
La notion de clone
la copie profonde d’un objet : comme précédemment, on recopie la valeur des champs d’un type
primitif. Mais pour les champs de type classe, on crée une nouvelle référence à un autre objet du
même type avec les mêmes valeurs.
La copie superficielle d’un objet : on se contente de recopier la valeur de tous ses champs, y
compris ceux de type classe.
Méthodes
Si une méthode fournir un résultat, donc le type du résultat doit figurer dans son en-
tête(avant le nom de la méthode) .
Sinon la méthode ne fournir aucun résultat, donc le mot clé void doit figurer dans son
en-tête à la place du type de la valeur de retour.
Comme dans tous les langages, les arguments figurant dans l’en-tête de la définition
d’une méthode.
Il est possible de déclarer un argument muet avec l’attribut final . Dans ce cas, le
compilateur s’assure que sa valeur n’est pas modifiée par la méthode
Méthodes
Conversion des arguments.
public void deplacer( int dx , int dy ) { dx dy }
.......
Point p = new Point ( 3, 5);
.......
int n1,n2;
byte b;
long q;
.......
[Link] (n1, n2) ; // OK : appel normal
[Link] (b+3, n1) ;// OK : b+3 est déjà de type int
[Link] (b, n1) ;// OK : b de type byte sera converti en int
[Link] (n1, q) ; // erreur : q de type long ne peut être converti en int
[Link] (n1, (int)q) ; // OK
Méthodes
Conversion des arguments.
public void deplacer(byte dx , byte dy ) { dx dy }
.......
Point p = new Point ( 3, 5);
.......
byte b1, b2;
.......
[Link] (b1, b2) ; // OK : appel normal
[Link] (b1+1,b2) ;// erreur : b1+1 de type int ne peut être converti en byte p.
[Link] (b1++, b2) ;// OK : b1++ est de type byte
Méthodes
La surcharge survient lorsque l'on a deux méthodes du même nom mais
qui ne prennent pas les mêmes paramètres..
Méthodes Quels résultats fournit ce programme ?
class A{
public class B{
public void f(int n,float x) {
public static void main(String args[]) {
[Link]("f(int n,float x) n="+n+"x="+x); }
A a=new A();
private void f(long q,double y) {
a.g();
[Link]("f(long q,double y) q="+q+"y="+y); }
[Link]("--- dans main de B");
public void f(double y1,double y2) {
int n=1; long q=12;
[Link]("f(double y1,double y2) y1="+y1+"y2="+y2); }
float x=1.5f; double y=2.5;
public void g() {
a.f(n,q);
int n=1; long q=12; float x=1.5f; double y=2.5;
a.f(q,n);
[Link]("--- dans g");
a.f(n,x);
f(n,q);
a.f(n,y);
f(q,n);
}
f(n,x);
}
f(n,y);
}}
Attributs statiques
Un attribut statique est un attribut qui est commun à tous les objets que vous pourrez
créer. On peut par exemple citer un compteur du nombres d'instances de classe que vous
aurez lancées.
L'avantage des attributs statiques est que vous pouvez y accéder même si vous n'avez pas créé
d'instance de votre classe. Ainsi, vous pourrez écrire si vous le souhaitez n'importe où dans une méthode ceci :
[Link]("Nombre d'instances crées : " + [Link]);
Méthodes statiques
Une méthode statique est une méthode qui peut être appelée même sans avoir instancié la
classe. Une méthode statique ne peut accéder qu'à des attributs et méthodes statiques.
Vous pouvez sans avoir instancié la classe accéder à la méthode statique en tapant ceci : :
[Link]();
Destruction des objets
L’espace mémoire occupé par tout objet qui n’est plus référencé est automatiquement
récupère au bout d’un certain temps par le Garbage Collector (ramasse-miette).
Il est possible, pour toute classe, d’écrire une méthode finalize, automatiquement invoquée
lorsqu’un objet va être récupéré par le Garbage Collector.
Manipulation des chaînes
La classe prédéfinie String
String e = ""; // Une chaine vide
String chaine = "Hello";
String chaine = new String("Hello");
Concaténation
String porte = "Porte";
String str= "Feuille";
String chaine = porte + str; // chaine vaut PorteFeuille (sans espace)
String rate = "PG" + 13; // rate vaut PG13
Manipulation des chaînes
Longueur d'une chaîne
String chaine = "Hello";
int n = [Link](); // donne n = 5
Extraction de sous-chaîne
On peut extraire une sous-chaîne à l'aide de la méthode substring. Deux versions existent :
[Link](debut) ou [Link](debut, fin)
debut: indice de départ est inclus
fin : indice de fin est exclusif
chaine = [Link](0, 3) + "p!"; // donne.......
Manipulation des chaînes
Les String de Java sont “immutable”, vous ne pouvez pas changer le caractère 'e' de la
String "Hello", si ce n'est en modifiant la valeur de la variable chaine et en la remplaçant comme
dans l'exemple précédent.
Remarque : Il existe une classe StringBuffer pour les chaînes modifiables
Manipulation des chaînes
Bien que le contenu d'une chaîne ne puisse pas être modifié, il est possible d'effectuer des
conversions en créant une nouvelle chaîne.
Les méthodes toLowerCase et toUpperCase permettent d'obtenir une chaîne
respectivement en minuscules et en majuscules.
La méthode trim permet d'obtenir une nouvelle chaîne sans espaces au début ou à la fin.
La méthode replace(oldChar, newChar) permet de remplacer tous les
caractères oldChar d'une chaîne par des caractères newChar.
Manipulation des chaînes
Une comparaison de chaînes s'effectue de la manière suivante :
[Link](chaine2)
Cette méthode retourne 0 si les deux chaînes sont égales, une valeur négative si chaine1 est
plus petit que chaine2, ou une valeur positive si chaine2 est plus petit que chaine1.
Il existe aussi la méthode
[Link]("Bonjour") renverra true si la String chaine est égale à «Bonjour »
[Link] ("BonJour") : compare la chaîne sans tenir compte de la casse.
NB : Il ne faut donc pas utiliser les opérateurs >, >=, <, <= et ==
== qui vérifie si les deux String sont stockées au même endroit.
Manipulation des chaînes
• int indexOf (int c) : indice du caractère c dans la chaîne ; -1 s’il n’existe pas.
• int indexOf (int c, int n) : indice d’un caractère c de la chaîne en partant de l’indice n.
• int indexOf (String s) : indice de la sous-chaîne s.
• int indexOf (String s, int n) : indice de la sous-chaîne s en partant d’un indice n.
• int lastIndexOf (int c) : indice du dernier caractère c.
• int lastIndexOf (int , int) : indice du dernier caractère en partant de la fin et d’un indice.
• int lastIndexOf (String) : indice de la dernière sous-chaîne.
• int lastIndexOf (String, int) : indice de la dernière sous-chaîne en partant d’un indice.
• String replace (char c1, char c2) : crée une nouvelle chaîne en remplaçant le caractère c1 par c2.
• boolean startsWith (String s) : teste si la chaîne de l’objet commence par s.
• boolean startsWith (String s, int n) : teste si la chaîne de l’objet commence par s en partant de l’indice n..
• boolean endsWith (String s) : teste si la chaîne de l’objet se termine par s.
• String trim () : enlève les espaces en début et fin de chaîne.