Module I5 – Java Corrigé TP2 RT I – Création d`une classe IUT

Module I5 – Java Corrigé TP2 RT
I – Création d'une classe
! Ne sont reproduites que les modifications apportées à l'application entre deux paragraphes.
1,1 – Classe Point
class Point {
int x,y;
void affiche() {
System.out.println("Point : x= " + x + " / y = " + y);
}
public static void main(String [] args) {
Point P1=new Point();
P1.affiche();
P1.x=5; P1.y=3;
P1.affiche();
}
}
1,2 – Indépendance des objets
Point P2=new Point(); // Ajout en fin de main
P2.affiche();
P2=P1; // ! A partir de ce point, P1 et P2 représentent le
P2.affiche(); // le même objet
P2.x=1; P2.y=2;
P1.affiche(); // Les 2 affichages sont donc identiques
P2.affiche();
=> L'opération P2=P1 entraine la même utilisation de l'espace mémoire par les 2 références.
Autrement dit, P2 et P1 représentent le même objet.
1,3 – Ajout de méthodes
void deplace(int dx, int dy) {
x+=dx; y+=dy;
}
void rotation() {
int c=x;
x=y; y=-c;
}
void normalise() {
if (x<0) x=-x;
if (y<0) y=-y;
}
... main ...
P1.deplace(5,-3); // Le point P1 est déplacé de 5 en x, et -3 en y
P2.rotation();
P1.normalise();
IUT Elbeuf 1 / 8 S.H.

Module I5 – Java Corrigé TP2 RT
1,4 – Comparaison d'objets
boolean testEgal(Point Px) {
if ((x==Px.x) && (y==Px.y)) return true;
else return false;
}
...main...
if(P1.testEgal(P2)) System.out.println("P1 et P2 sont identiques");
else System.out.println("P1 et P2 sont différents");
1,5 – Constructeur
Pour l'instant, la classe Point utilise le constructeur par défaut généré par Java. Ce constructeur est
utilisé dans le main lors de la création d'un nouvel objet :
Point P2=new Point(); // Utilisation du constructeur par défaut Point()
! Ce constructeur est généré par Java
Point(int a, int b) {
x=a; y=b;
}
...main...
Point P3=new Point(1,2); // Utilisation du constructeur Point(int a, intb)
Maintenant, le constructeur par défaut ne fonctionne plus. En effet, lorsque vous définissez un
constructeur pour votre classe, Java ne génère plus de constructeur par défaut : vous devez le recréer si vous
en avez besoin.
Point() { // Redéfinition du constructeur par défaut
}
Remarques : Un constructeur porte strictement le même nom que la classe
Soyez attentif au format d'écriture du constructeur (pas de void, ...)
1,6 – Surcharge de méthodes
Point(Point Px) {
x=Px.x; y=Px.y;
}
...main...
Point P4=new Point(P1); // Utilisation du constructeur Point(Point Px)
1,7 – Domaine d'existence des variables
1,7,1 – Modification du constructeur
Point(int x, int y) {
this.x=x; this.y=y; // Le mot clé "this" permet d'accéder aux variables
}// de l'objet, le x seul faisant référence à l'argument
Les 2 constructeurs cohabitent sans problème (principe de la prog. Objet). Java reconnaît le modèle
au format et au nombre d'argument.
IUT Elbeuf 2 / 8 S.H.

Module I5 – Java Corrigé TP2 RT
1,7,2 – initPoint
Point() { initPoint(0,0); }
Point(int x, int y) { initPoint(x,y); }
Point(Point Px) { initPoint(Px.x, Px.y); }
void initPoint(int a, int b) { x=a; y=b; }
1,8 – Utilisation de variables statiques
1,8,1 – copiePoint
Point copiePoint() {
Point Pr=new Point();
Pr.x=x;
Pr.y=y;
return Pr;
}
Peut être optimiser par Point copiePoint() {
Point Pr=new Point(this);
return Pr;
}
La meilleure des versions Point copiePoint() {
return new Point(this);
}
...main...
P2=P1.copiePoint();
1,8,2 – copiePoint : version statique
Puisque la méthode devient statique, elle ne peut plus faire référence à l'objet d'appel. Il faut donc lui
passer les valeurs en argument :
static Point copiePoint(Point Pr) {
return new Point(Pr);
}
...main...
P2=P1.copiePoint(P1); // Ces 3 écritures sont strictement équivalentes
P2=P2.copiePoint(P1);
P2=Point.copiePoint(P1);
IUT Elbeuf 3 / 8 S.H.

Module I5 – Java Corrigé TP2 RT
1,8,3 – Compteur
méthode 1
static cmpt=0;
Point() { cmpt++; initPoint(0,0); }
Point(int x, int y) { cmpt++; initPoint(x,y); }
Point(Point Px) { cmpt++; initPoint(Px.x, Px.y); }
void initPoint(int a, int b) { x=a; y=b; }
méthode 2
static cmpt=0;
Point() { initPoint(0,0); }
Point(int x, int y) { initPoint(x,y); }
Point(Point Px) { initPoint(Px.x, Px.y); }
void initPoint(int a, int b) { x=a; y=b; cmpt++;}
=> Pour les 2 méthodes, il faut également ajouter l'affichage de cmpt dans la méthode affiche()
Le compteur cmpt est initialisé au niveau de sa déclaration dans la classe (non obligatoire si = 0)
La méthode 2 présente l'avantage de ne nécessiter qu'une seule fois l'opération, puisque l'appel à la méthode
initPoint est ici systématique dans tous les constructeurs.
Cmpt déclaré en statique, donc élément commun à tous les objets de type Point. L'accès peut être réalisé de
façon équivalente par les lignes suivantes :
P1.cmp <=> P2.cmpt <=> Point.cmpt
1,8,4 – Somme
Point somme(Point Ps) {
Point Pt=new Point();
Pt.x=x+Ps.x;
Pt.y=y+Ps.y;
Pt.affiche();
return Pt;
}
... main ...
P4.affiche();
P4=P1.somme(P2);
P4.affiche();
=> On remarque grâce à l'affichage, que chaque appel au constructeur incrémente le compteur
cmpt, y compris pour la création d'un élément temporaire (Pt créé dans la méthode somme)
IUT Elbeuf 4 / 8 S.H.

Module I5 – Java Corrigé TP2 RT
II – Utilisation de projet
2,1 – 2 classes dans un fichier
class Rectangle {
Point Ph, Pb;
void affiche() {
System.out.println("Rectangle : Ph = ("+Ph.x+","+Ph.y+") / ("
+Pb.x+","+Pb.y+")");
}
void initRect(int a, int b, int c, int d) {
Ph.x=a; Ph.y=b;
Pb.x=c; Pb.y=d;
}
void initRect(Point P1, Point P2) {
Ph.x=P1.x; Ph.y=P1.y;
Pb.x=P2.x; Pb.y=P2.y;
}
... main ...
Rectangle R=new Rectangle();
R.affiche();
R.initRect(1,2,3,4);
R.affiche();
Point P1=new Point(10,11);
Point P2=new Point(20,21);
R.initRect(P1,P2);
R.affiche();
=> Pour que le programme fonctionne, il faut repecter les points suivants :
–1 seule classe est déclarée publique dans le fichier
–La classe Point, et la classe Rectangle sont déclarée dans le même fichier
2.2 – 2 classes dans un fichier séparé
=> Principe :
–A l'aide d' un copier coller pour obtenir dans le même répertoire 2 fichiers au contenu identique, mais
dont l'un s'appelle Point, et l'autre Rectangle (du nom des 2 classes utilisées)
–Dans chacun des fichiers, ne conserver que la classe correspondant au nom du fichier, en la déclarant en
publique
–Compilez les 2 fichiers, et lancez l'exécution (sur le fichier contenant le main)
Remarque : Quelque soit la classe contenant le main, le fonctionnement sera identique
IUT Elbeuf 5 / 8 S.H.