Classes et Objets

(2ème partie)
dernière mise à jour 10/01/2023 23:04

Philippe Genoud
[email protected]

© Philippe GENOUD UGA Janvier 2023 1

Plan
 Constructeurs
 Surcharge des méthodes

 Variables de classe (variables statiques)

 Méthodes de classe (méthodes statiques)

 Constantes

 Le main()

 Initialiseur statique

 Finalisation

© Philippe GENOUD UGA Janvier 2023 2

Constructeurs le retour

 Constructeurs d’une classe:

 méthodes particulières pour la création d'objets de cette classe, invoquées par l’opérateur new

 méthodes dont le nom est identique au nom de la classe.

 pas de type de retour ni mot void dans la signature

 retourne implicitement instance de la classe (this)

 pas d ’instruction return dans le constructeur

 Rôled'un constructeur
 effectuer certaines initialisations nécessaires pour le nouvel objet créé.

 Toute classe JAVA possède au moins un constructeur

 Constructeur définit explicitement dans le code de la classe,

 Ou un constructeur par défaut sans arguments et qui n'effectue aucune initialisation particulière est
invoqué

© Philippe GENOUD UGA Janvier 2023 3

 Constructeurs Définition explicite
 si une classe ne définit pas explicitement de constructeur, un constructeur par défaut sans arguments
et qui n'effectue aucune initialisation particulière est invoqué
public class Point {
private double x;
private double y; Point p1 = new Point();
pas de constructeur déclaré :
public Point(){ constructeur par défaut (sans paramètre
}
et sans instructions)
public void translater(double dx, double dy) {
x += dx; y += dy;
}
public double distance() {
return Math.sqrt(x*x+y*y);
}
public void setX(double x){
this.x = x;
}
public double getX(){
return x;
}
… idem pour y
}

© Philippe GENOUD UGA Janvier 2023 4

Constructeurs Définition explicite
 si une classe définit explicitement un constructeur le constructeur par défaut est masqué, seuls le ou
les constructeurs définis peuvent être invoqués
public class Point {
private double x;
private double y; Point p1 = new Point();
public Point(double x, double y){
this.x = x; Le constructeur par défaut (sans
public Point(){
} this.y = y; paramètre et sans instructions) ne peut
} plus être invoqué, il faut obligatoirement
public void translater(double dx, double dy) { passer par le constructeur déclaré
x += dx; y += dy;
} Point p1 = new Point(10,10);
public double distance() {
return Math.sqrt(x*x+y*y);
}
public void setX(double x){
this.x = x;
}
public double getX(){
return x;
}
… idem pour y
}

© Philippe GENOUD UGA Janvier 2023 5

 Constructeurs Constructeurs multiples
 Parfois nécessité d'initialiser un objet de plusieurs manières différentes
 Possibilité de définir plusieurs constructeurs dans une même classe
public class Point {
• créer un point à l’origine
private double x;
private double y; • créer un point à partir d’un autre point
• chaque constructeur possède le même nom (le nom
public Point(double x, double y){
public Point(){
this.x = x; de la classe)
} this.y = y; • le compilateur distingue les constructeurs en fonction :
} • du nombre
• du type
public Point(){ • de la position des arguments
...
} Point p1 = new Point(10,10);

Point p2 = new Point();

public Point(Point p){
this.x = p.x;
Point p3 = new Point(p1);
this.y = p.y;
}
• on dit que les constructeurs peuvent sont surchargés
(overloaded)
...
}

© Philippe GENOUD UGA Janvier 2023 6

Constructeurs
Appel d’un constructeur par un autre constructeur

 dans une classe définissant plusieurs constructeurs, un constructeur peut invoquer

un autre constructeur de cette classe
 appel this(...)
 fait référence au constructeur de la classe dont les arguments correspondent,
 ne peut être utilisé que comme première instruction dans le corps d’un constructeur,
il ne peut être invoqué après d'autres instructions*
 Intérêt
 factorisation du code,
 un constructeur général invoqué par des constructeurs particuliers,

 possibilité de définir des constructeurs privés.

* on comprendra mieux cela lorsque l'on parlera de l'héritage et de l'invocation automatique des constructeurs de la super-classe

© Philippe GENOUD UGA Janvier 2023 7

Constructeurs
Appel d’un constructeur par un autre constructeur
 exemple

public class Point {

private double x;
private double y;

// constructeurs
public
private Point(double x, double y) { Constructeur privé uniquement
this.x = x; accessible dans la classe où il est
défini
this.y = y;
}

public Point(Point p) {
xthis(p.x,p.y);
= p.x; y = p.y;
}

public Point() {
xthis(0.0,0.0);
= 0.0; y= 0.0;
}

...
}

© Philippe GENOUD UGA Janvier 2023 8

Surchage des méthodes
 surcharge (overloading) pas limitée aux constructeurs, elle est possible pour n'importe
quelle méthode

 possiblede définir des méthodes possédant le même nom mais dont les arguments
diffèrent

 lorsque qu'une méthode surchargée est invoquée

 le compilateur sélectionne automatiquement la méthode dont le nombre et le type des arguments
correspondent au nombre et au type des paramètres passés dans l'appel de la méthode

 des
méthodes surchargées peuvent avoir des types de retour différents mais à
condition qu'elles aient des arguments différents

© Philippe GENOUD UGA Janvier 2023 9

Surcharge des méthodes exemple
 Exemple de surcharge de méthode : distance d’un point à l’origine, distance d’un point avec un autre point
public class Point {
// attributs
private double x;
private double y;
Point p1=new Point(10,10);
// constructeurs
Point p2=new Point(15,14);
public Point(double x, double y){
...
double d = p1.distance();
}
double d12 =p1.distance(p2);
// méthodes
public double distance() {
return Math.sqrt(x * x + y * y); La méthode distance est surchargée
}

public double distance(Point p){

return Math.sqrt((x - p.x) * (x - p.x)
+ (y - p.y) * ( y - p.y));
}
...
}
© Philippe GENOUD UGA Janvier 2023 10
Variables de classes
public class Point { Modifier la classe Point afin de pouvoir modifier la valeur de
/**
* abscisse du point la constante d’imprécision
*/
private double x;

/**
* ordonnée du point
*/
private double y;

...
/**
* Compare 2 points cartésiens
* @param p l'autre point
* @return true si les points sont égaux à 1.0e-5 près
*/
public boolean egale(Point p) {
double dx= x - p.x
double dy= y – p.y;
if(dx<0)
dx = -dx;
if(dy<0)
dy= - dy;
return (dx < 1.0e-5 && dy < 1.0e-5);
}
* En général on ne définit pas une méthode d’égalité de cette manière, ont
... préfère redéfinir la méthode equals(Object) , mais on en reparlera lors
} du cours sur l’héritage

© Philippe GENOUD UGA Janvier 2023 11

Variables de classes
public class Point { Modifier la classe Point afin de pouvoir modifier la valeur de
/**
* abscisse du point la constante d’imprécision
*/ 1ère solution :
private double x;
Ajouter une variable (un attribut) eps à la classe
/** /** imprécision pour tests d’égalité
* ordonnée du point */
*/ private double eps = 1.0e-5;
private double y;
Définir un accesseur et un « modifieur »
...
/** /** fixe imprécision pour tests d’égalité
* Compare 2 points cartésiens * @param newEps valeur de l’imprécision
* @param p l'autre point */
eps près
* @return true si les points sont égaux à 1.0e-5 public void setEps(double newEps) {
*/ this.eps = Math.abs(newEps);
public boolean egale(Point p) { }
double dx= x - p.x
double dy= y – p.y; /**
if(dx<0) * @return valeur imprécision
dx = -dx; */
if(dy<0) public double getEps() {
dy= - dy; return eps;
return (dx < 1.0e-5
eps && dy < 1.0e-5);
eps }
}

... Quels sont les problèmes liés à cette solution ?

}

© Philippe GENOUD UGA Janvier 2023 12

 Variables de classe
 Chaque instance possède sa propre valeur de précision egale n’est plus garantie comme étant symétrique
p1
x 10 Point p1 = new Point(10,14);
y 14
Point p2 = new Point(10.001,14.001);
eps 1.0e-5
p2.setEps(10e-2);
x 10.001
p2 System.out.println(p1.egale(p2));  false utilise la précision de p1 (0.00001)
y 14
eps 1.0e-2 System.out.println(p2.egale(p1));  true utilise la précision de p2 (0.01)

 Duplication des valeurs au niveau de chaque instance

x 10 x 10 x 34
y 14 y 14 … y 17
eps 1.0e-5 eps 1.0e-2 eps 1.0e-5

 Cette information ne concerne pas une instance particulière mais à l’ensemble des instances de Point
x 10 x 10 x 34
y 14 y 14 … y 17

Valeur associée à l’ensemble

Mais en Java, rien ne peut être défini en dehors d’un objet.
eps 1.0e-5
des points cartésiens Pas de variables globales  Comment procéder ?

© Philippe GENOUD UGA Janvier 2023 13

 Variables de classe
 Pour chaque classe utilisée il existe un objet-classe la représentant, instance de la classe Class du package java.lang

Extraits de la java doc de la classe Class

Objet représentant la
 Chaque instance possède une référence sur l’objet représentant sa classe classe Class
Point p1 = new Point(10,14); isa isa
System.out.println(p1.getClass().getName()); ----> Point name "Class"

objet de type Class représentant la classe des Points isa isa

Objet représentant name "String"
la classe Point
Objet représentant la
isa
classe String
Définir eps comme attribut de l’objet name isa
représentant la classe Point eps 1.0e-5 "Point"

isa isa isa

x 10 x 10 x 34
y 14 y 14 … y 17

© Philippe GENOUD UGA Janvier 2023 14

 Variables de classe
 Comment définir eps comme attribut de l’objet-classe représentant la classe Point ?
 Dans le code source la classe Point
 Pour cela il faut distinguer le niveau auquel s’appliquent les descriptions (à l’objet-classe représentant Point ou aux
instances de la classe Point)
 Les descriptions qui concernent l’objet-classe sont précédées du mot clé static
Objet représentant la
classe Class
isa isa
public class Point {
name "Class"

Variable statique : private

private static
double double eps = 1.e-5;
eps = 1.e-5;
variable de classe isa isa
/** Objet représentant name "String"
* abscisse du point la classe Point
Objet représentant la
*/ isa
classe String
private double x; name isa

variables d’instances eps 1.0e-5 "Point"

/**
* ordonnée du point Objets instances la
*/ classe String
private double y;
isa isa isa

... x 10 x 10 x 34
y 14 y 14 … y 17

Objets instances la classe Point

© Philippe GENOUD UGA Janvier 2023 15
 Variables de classe
 Comme les autres attributs, les variables de classe sont /** fixe imprécision pour tests d’égalité
accessibles partout dans le code de la classe * @param newEps valeur de l’imprécision
*/
public void setEps(double newEps) {
eps = newEps;
}

/** @return valeur imprécision

*/
public double getEps() {
return eps;
public class Point { }

Variable statique : private static double eps = 1.e-5; /** Compare 2 points cartésiens
* @param p l'autre point
variable de classe
* @return true si les points sont égaux à eps près
/** */
* abscisse du point public boolean egale(Point p) {
*/ double dx= x - p.x
private double x; double dy= y – p.y;
variables d’instances if(dx < 0)
/** dx = -dx;
* ordonnée du point if(dy < 0)
*/ dy= - dy;
private double y; return (dx < eps && dy < eps);
}
...
...
}

© Philippe GENOUD UGA Janvier 2023 16

Variables de classe
 Comment accéder à esp depuis un code extérieur à la
classe Point ? public class Point {

 Appeler les méthode getEps et setEps ? private static double eps = 1.e-5;
...
Mais nécessité de passer par une instance de la classe Point
Point p = new Point (…);
System.out.println(p.getEps()); /**
p.setEps(1.e-8); * fixe imprécision pour tests d’égalité
* @param newEps valeur de l’imprécision
*/
public void setEps(double newEps) {
eps = newEps;
}

/*
* @return valeur imprécision
*/
public double getEps() {
return eps;
}

...
}

© Philippe GENOUD UGA Janvier 2023 17

Variables de classe
 Comment accéder à esp depuis un code extérieur à la
classe Point ? public class Point {

 Comme pour les variables, possibilité d’associer des private static double eps = 1.e-5;
...
méthodes à un objet-classe en ajoutant le modifieur
static à sa déclaration  méthodes statiques ou
méthode de classe /**
* fixe imprécision pour tests d’égalité
 Méthodes statiques peuvent être invoquées sans * @param newEps valeur de l’imprécision
nécessité de passer par une instance de la classe, on y */
public void setEps(double newEps) {
accède directement par l’objet-classe qui peut être eps = newEps;
désigné par le nom de la classe } Les méthodes setEps et
getEps ne sont plus
System.out.println(Point.getEps()); /* associées aux instances de
Point.setEps(1.e-8); * @return valeur imprécision la classe Point mais à
*/ l’objet-classe Point
Méthode statique public double getEps() {
return eps;
désigne l’objet-classe représentant la classe Point
}
le nom de la classe est l’identificateur de la référence créée par défaut pour désigner l’objet-classe
...
 Attention : à l’intérieur du corps d’une méthode statique il n’est }

possible d’accéder qu’aux membres (attributs ou méthodes)

statiques de la classe (qui serait this ?)

© Philippe GENOUD UGA Janvier 2023 18

Api de la classe Class
public String getName()
Returns the name of the entity (class, interface, array class, primitive type, or void) represented by this
Class object, as a String.

public Class getSuperclass()

Returns the Class representing the superclass of the entity (class, interface, primitive type or void)
represented by this Class

public Object newInstance() throws InstantiationException,

IllegalAccessException
Creates a new instance of the class represented by this Class object.
…
Les membres d’une classes sont eux-mêmes représentés par des objets dont les classes sont définies dans
java.lang.reflect. (Introspection des objets)

public Field getField(String name) throws NoSuchFieldException, SecurityException

Returns a Field object that reflects the specified public member field of the class or interface
represented by this Class object.

public Method[] getMethods() throws SecurityException

Returns an array containing Method objects reflecting all the public member methods of the class
or interface represented by this Class object, including those declared by the class or interface
and those inherited from superclasses and superinterfaces.

© Philippe GENOUD UGA Janvier 2023 19

Variables de classe Constantes

 Desconstantes nommées peuvent être définies par des variables de classe dont la valeur
ne peut être modifiée
public class Pixel {
Déclarations de variables de
public static final int MAX_X = 1024;
public static final int MAX_Y = 768;
classe

// variables d'instance
private int x; Le modifieur final est utilisé pour
private int y;
indiquer que la valeur d'une variable
...
// constructeurs (ici de classe) ne peut jamais être
changée
// crée un Pixel de coordonnées x,y
public Pixel()
{
...
}
...
}

© Philippe GENOUD UGA Janvier 2023 20

Membres statiques Synthèse

 membres dont la déclaration est précédée du modifieur static

 variables de classe : définies et existent indépendamment des instances
 méthodes de classe : dont l’invocation peut être effectuée sans passer par l’envoi d’un message à l’une
des instances de la classe.

 accès aux membres statiques

 directement par leur nom dans le code de la classe où ils sont définis,
 en les préfixant du nom de la classe en dehors du code de la classe
 NomDeLaClasse.nomDeLaVariable

 NomDeLaClasse.nomDeLaMéthode(liste de paramètres)
 n'est pas conditionné par l'existence d'instances de la classe,
Math.PI Math.cos(x) Math.toRadians(90) ...

© Philippe GENOUD UGA Janvier 2023 21

System.out.println ???

System.out.println("COUCOU");

Classe System
du package java.lang

Variable de classe
(référence un objet de type
PrintStream)

Méthode d ’instance de
la classe PrintStream
du package java.io

© Philippe GENOUD UGA Janvier 2023 22

 Le main()
 Le point d ’entrée pour l’exécution d ’une application Java est la méthode statique main de
la classe spécifiée à la machine virtuelle
 Signature (profil) de cette méthode public static void main(String[] args)
 args : tableau d’objets String (chaînes de caractères) contenant les arguments de la ligne de commande

public class TestArgs {

public static void main(String[] args) {

System.out.println("nombre d ’arguments : " + args.length);
for (int i =0; i < args.length; i++) {
System.out.println(" argument " + i + " = " + args[i]);
}
}

nombre d ’arguments : 3
java TestArgs arg1 20 35.0 argument 0 : arg1
argument 1 : 20
argument 2 : 35.0

© Philippe GENOUD UGA Janvier 2023 23

Le main()
 Les différentes classes d’une même application peuvent éventuellement chacune contenir leur propre
méthode main()
 Au moment de l’exécution pas d’hésitation quant à la méthode main() à exécuter
 c’est celle de la classe indiquée à la JVM

MaClasse1.java
public class MaClasse3 {

... _main
java MaClasse1
...
MaClasse2.java
public class MaClasse2 { MaClasse1.class
... public static void
main(String[] args) {
java MaClasse3
MaClasse3.java ...

}
public class MaClasse1 {

... }

MaClasse2.class
javac
public static void }
main(String[] args) {

...
_main
} ...

MaClasse3.class

© Philippe GENOUD UGA Janvier 2023 24

Initialisation des variables à la déclaration

 les variables d'instance et de classe peuvent avoir des "initialiseurs" associés à leur
déclaration modifieurs type nomDeVariable = expression ;
private double x = 10;
private double y = x + 2;
private double z = Math.cos(Math.PI / 2);
private static int nbPoints = 0;

 variables de classe initialisées la première fois que la classe est chargée.

 variables d'instance initialisées lorsqu'un objet est créé.
 les initialisations ont lieu dans l’ordre des déclarations.

public class TestInit {

javac TestInit.java [4:1] illegal forward reference
private double y = x + 1; private double y = x + 1;
private double x = 14.0; ^
1 error
... Errors compiling TestInit.
}

© Philippe GENOUD UGA Janvier 2023 25

Initialisation des variables
initialiseurs statiques
 siles initialisations nécessaires pour les variables de classe ne peuvent être faites
directement avec les initialiseurs (expression) JAVA permet d'écrire une ou des
instructions (algorithme) d'initialisation pour celles-ci : initialiseurs statiques

xs un nombre tiré au hasard entre 0 et 10

ys somme de n nombres tirés au hasard, n étant la partie entière de xs
zs somme de xs et ys  Déclaration d’un initialiseur statique
 static { bloc de code }
private static double xs = 10 * Math.random();
 méthode
private static double ys; = ????
 sans paramètres
private
static {static double zs = xs + ys;
int n = (int) xs;  sans valeur de retour
ys = 0;  sans nom
for (int i = 0; i < n; i++)
ys = ys + Math.random();  Invocation
}
 automatique et une seule fois lorsque la classe est chargée

 dans l’ordre d’apparition dans le code de la classe

© Philippe GENOUD UGA Janvier 2023 26

Destruction des objets rappels

 libération de la mémoire alloué aux objets est automatique

 lorsqu'un objet n'est plus référencé le "ramasse miettes" ("garbage collector") récupère l'espace
mémoire qui lui était réservé.
 le
"ramasse miettes" est un processus (thread) qui s'exécute en tâche de fond avec un
priorité faible
 s'exécute :
 lorsqu'il n'y a pas d'autre activité (attente d'une entrée clavier ou d'un événement souris)
 lorsque l'interpréteur JAVA n'a plus de mémoire disponible
– seul moment où il s'exécute alors que d'autres activités avec une priorité plus forte sont en cours (et ralentit donc
réellement le système)

 peut
être moins efficace que gestion explicite de la mémoire , mais programmation
beaucoup plus simple et sure.

© Philippe GENOUD UGA Janvier 2023 27

 Destruction des objets finalisation

 "ramasse miettes" gère automatiquement ressources mémoire utilisées par les objets
 un objet peut parfois détenir d'autres ressources (descripteurs de fichiers, sockets....) qu'il
faut libérer lorsque l'objet est détruit.
 méthode dite de "finalisation" prévue à cet effet
 permet de fermer les fichiers ouverts, terminer les connexions réseau... avant la destruction des objets
 la méthode de "finalisation" :
 méthode d'instance
 doit être appelée finalize()

 ne possède pas de paramètres , n'a pas de type de retour (retourne void)

 est invoquée juste avant que le "ramasse miette" ne récupère l'espace mémoire associé à l'objet

© Philippe GENOUD UGA Janvier 2023 28

 Destruction des objets finalisation exemple

class Point { Point p1 = new Point(14,14);

private double x; Point p2 = new Point(10,10);
private double y; System.out.pritnln(p1);
System.out.pritnln(p2);
public Point(double x, double y) { p1.translater(10,10);
this.x = x; p1 = null;
Appel explicite au
this.y = y; System.gc();
} System.out.pritnln(p1); garbage collector
System.out.pritnln(p2);
public void translater(double dx, double dy) {
x += dx;
y += dy;
}

public String toString() { Point[x:14.0, y:14.0]

return "Point[x:" + x + ", y:" + y + "]";
Point[x:10.0, y:10.0]
}
finalisation de Point[x:24.0, y:24.0]
public void finalize() { null
System.out.println("finalisation de " + this); Point[x:10.0, y:10.0]
}
}

© Philippe GENOUD UGA Janvier 2023 29

 Destruction des objets finalisation

 JAVA ne donne aucune garantie sur quand et dans quel ordre la récupération de la mémoire
sera effectuée,

 impossible de faire des suppositions sur l'ordre dans lequel les méthodes de finalisation seront invoquées.

 il vaut mieux éviter de définir et de compter sur des "finaliseurs" pour libérer des ressources critiques

 il vaut mieux compter sur une méthode explicite de terminaison

 ex : méthode close() d'un connexion JDBC (base de données)

voir Chapter 2. Creating and Destroying Objects - Item 7

du livre Effective Java™, Second Edition, Joshua Bloch, Ed. Addison-Wesley Professional - 2008
http://www.codeproject.com/Articles/30593/Effective-Java

© Philippe GENOUD UGA Janvier 2023 30