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();
P2.affiche();
P2=P1;
P2.affiche();
P2.x=1;
P2.y=2;
P1.affiche();
P2.affiche();
// Ajout en fin de main
// ! A partir de ce point, P1 et P2 représentent le
// le même objet
// Les 2 affichages sont donc identiques
=> 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);
P2.rotation();
P1.normalise();
IUT Elbeuf
// Le point P1 est déplacé de 5 en x, et -3 en y
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))
else
}
...main...
if(P1.testEgal(P2))
else
return
true;
return false;
System.out.println("P1 et P2 sont identiques");
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.
// Redéfinition du constructeur par défaut
Point() {
}
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);
P2=P2.copiePoint(P1);
P2=Point.copiePoint(P1);
IUT Elbeuf
// Ces 3 écritures sont strictement équivalentes
3/8
S.H.
Module I5 – Java
Corrigé TP2
RT
1,8,3 – Compteur
méthode 1
static cmpt=0;
Point()
Point(int x, int y)
Point(Point Px)
{
{
{
cmpt++;
cmpt++;
cmpt++;
void initPoint(int a, int b) {
x=a;
initPoint(0,0);
}
initPoint(x,y);
}
initPoint(Px.x, Px.y); }
y=b;
}
méthode 2
static cmpt=0;
Point()
Point(int x, int y)
Point(Point Px)
{
{
{
initPoint(0,0);
}
initPoint(x,y);
}
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.
Module I5 – Java
Corrigé TP2
RT
2.3 – 2 fonctions main
=> Principe :
–
–
A l'aide d'un copier coller, recopier la fonction main à l'identique dans les 2 fichiers.
Au début de la fonction main, dans chaque fichier, insérer la ligne de code :
–
Lancer l'exécution depuis l'un ou l'autre des fichiers
System.out.println("Execution du code main du fichier ...");
// Remplacer ... par le nom du fichier
=> On constate alors que le main exécuté correspond à la fonction "main" du fichier qui a permis de
démarrer l'exécution de l'application.
2.4 – Classe PointColor
public class Point {
...
}
class PointColor {
int x,y;
String color=new String();
void affiche() {
System.out.print("Point : x= " + x + " / y = " + y );
System.out.println(" / Couleur = " + color);
}
PointColor() {
}
PointColor(int a, int b, String s) {
x=a; y=b; color=s;
}
...
// Suite identique à Point
}
–
L'utilisation de la classe "PointColor" ne pose pas de problème au niveau de la fonction main contenue
dans la classe Point (même fichier)
–
Par contre, dans la méthode main contenue dans la classe Rectangle, il n'est pas possible de l'exploiter.
Ceci est dû au fait que ces 2 éléments sont déclarés dans des fichiers séparés, et que la classe
"PointColor" ne soit pas déclarée en classe publique.
IUT Elbeuf
6/8
S.H.
Module I5 – Java
Corrigé TP2
RT
III – Utilisation de tableaux
3,1 – Tableaux simple dimension
public class SaisieTableau
{
public static void main(String[] args) throws IOException {
BufferedReader clavier = new BufferedReader(
new InputStreamReader(System.in));
String s;
int n=0;
int tab[]=new int[10];
for (n=0; n<10; n++) {
System.out.print("Entrez la valeur de n" + n + " : ");
s=clavier.readLine();
tab[n]=Integer.ParseInt(s);
}
System.out.print("Valeurs saisies : ");
for (n=0; n<10; n++) {
System.out.print("Valeur de n" + n + " : ");
}
}
}
3,2 – Tri à bulle
Listing de la fonction tri, inséré à la fin du code précédent.
int z;
for (n=0; n<9; n++) {
if (tab[n] > tab[n+1]
{
z=tab[n];
tab[n]=tab[n+1];
tab[n+1]=z;
if (n>0)
n-=2;
}
}
System.out.print("Valeurs triées : ");
for (n=0; n<10; n++) {
System.out.print("Valeur de n" + n + " : ");
}
3,3 – Utilisation d'un tableau à 2 dimensions
int tab[][]=new int[5][2];
int n,m;
for ( n=0 ; n<2 ; n++) {
for ( m=0; m<5; m++) {
...
IUT Elbeuf
7/8
S.H.
Module I5 – Java
Corrigé TP2
RT
IV – Traitement de chaînes de caractères
...
BufferedReader clavier = new BufferedReader(new InputStreamReader(System.in));
String s;
System.out.print("Entrez un texte : ");
s=s.toUpperCase();
System.out.print("En majuscule s=>"+s);
s=s.toLowerCase();
System.out.print("En minuscule s=>"+s);
IUT Elbeuf
8/8
S.H.