Solution TD1 :

1. Le nom de la classe est : Rectangle.

2. La classe a quatre attributs : x, y , longueurX , longueurY.
3. Les méthodes de la classe Rectangle sont : Deplacer_vers , get_Surface , get_Perimetre et
Afficher_position.
4. Le code qui crée un objets Rectangle avec : x =2 , y = 5 , longueurX= 3 longueurY = 7

Rectangle r ;
Ou : Rectangle r = new Rectangle () ;
r = new Rectangle () ;
r.x= 2 ;
r.y = 5 ;

r. longueurX = 3 ;

r. longueurY= 7 ;

5. Représentation de l’objets :
r

x=2
y= 5
longueurX= 3
longueurY = 7
Deplacer_de (double a, double b)
get_Surface ()
get_Perimetre ()
Afficher_position ()

6. Donner les résultats du code suivant : r

a) Rectangle r ; // déclaration d’un objet r de la classe Rectangle
x= 0.0
b) r = new Rectangle () ; // creation d’une instance (objet) de la classe Rectangle. y= 0.0
longueurX= 0.0
c) r. longueurX =4 ; // longueurY = 0.0
…………
d) r. longueurY =3 ; r
r x= 0.0
y= 0.0
x= 0.0 longueurX= 4.0
y= 0.0 longueurY = 0.0
longueurX= 4.0
longueurY = 3.0
…………
…………

e) System.out.println ("surface : " + r.get_Surface ( ) ) ; // surface : 12.0

1
 f) r. x =4 ;
g) r. y =3 ; r

r x= 4.0
y= 0.0
x= 4.0 longueurX= 4
y= 3.0 longueurY = 3
longueurX= 4 …………
longueurY = 3
…………

h) r. Afficher_position ( ) ; // le point bas et à gauche de rectangle est dans la position : (4,3)

i) r. Deplacer _vers ( 1,2) ;
r
x= 1.0
y= 2.0
longueurX= 4.0
longueurY = 3.0
…………

j) r. Afficher_position ( ) ; // le point bas et à gauche de rectangle est dans la position : (1,2)

7. Ecrire le code correspondant aux opérations suivantes :

a) Deplace le rectange vers le haut de 2 unités.
r.Deplacer_vers (1,4) ; ou r.y = r.y +2 ; ou r.Deplacer_vers (r.x , r.y +2) ;
b) Afficher le périmètre de rectangle
System.out.println (r.get_Perimetre () ) ;

Exercice 02 :
class Time {
String Pays;
byte Seconde ;
byte Minute ; Ou : byte Second,Minute, Heure ;
byte Heure;

void affiche_heure() {
System.out.println (Heure+“:“+Minute+“:“+Seconde);
}

2
 1. Time instant = new Time() ; // creation d’une instance de la classe Time.

instant
Si on veut changer les valeurs des attributs de instatnt on écrit : Pays = null
Heure= 0
instant.Pays = “Algérie”; Minute =0
instant.Heure = 14; instant Seconde= 0
Pays =“Algérie“
instant.Minute = 2;
Heure= 14
instant.Seconde =12 ; Minute = 2
Seconde= 12

2. Instant.affiche_heure(); il affiche sur l’écran : 14:2:12

Exercice 03
1- Ecrire une classe Point avec les attributs suivants: x : L'abscisse du point et y : L'ordonnée du point.

class Point {
double x ;
double y ;
}

2- Ecrire une méthode Deplacer_Point qui permet de deplacer un point donné vers une nouvelle position.

class Point {
double x ;
double y ;
// solution 01
void deplacer_Point ( double a , double b)
{
x=a;
y=b;
}
// solution 02
void deplacer_Point ( Point c)
{
x = c.x ;
y = c.y ;
}
}

3
 3- Définir une classe Rectangle permettant de manipuler de tels objets (utiliser la classe Point).

class Rectangle {
Point gbase ;
double longueurX;
double longueurY;
}

4- Définir deux constructeurs prenant respectivement en paramètre : 1 points et 2 longueurs, et 2 points,

class Rectangle {
Point gbase ;
double longueurX;
double longueurY;

// constructeur avec 1 points et 2 longueurs

Méthode 01 : si on considère que les logueurs sont positifs :
Rectangle ( Point p , double longX , double longY ) {
gbase = p ;
longueurX = Math.abs (longX) ;
longueurY = Math.abs (longY) ;
}

4
 Méthode 02 : si on considère que les logueurs peuvent être negatifs:
Rectangle ( Point p , double longX , double longY ) {
gbase = new Point( ) ; // création de point gbase.
if ((longX <0 ) && (longY<0 )) {
gbase.x = p.x + longX ; si gbase n’est pas créé
gbase.y = p.y + longY ; On ne peut pas écrire DIRECTEMENT
}
gbase.x = p.x + longX ; // NON
if ((longX < 0 ) && (longY > 0 )) { gbase.y = p.y + longY ; // NON
gbase.x = p.x + longX;
- Mais on peut écrire
gbase.y = p.y ;
gbase = p ; // p :un objet de type
}
point même si gbase n’est pas créé.
if ((longX > 0 ) && (longY < 0 )) {
gbase.y = p.y + longY;
gbase.x = p.x ;
}

if ((longX > 0 ) && (longY > 0 )) {

gbase = p;
}

longueurX = Math.abs(longX) ;
longueurY = Math.abs(longY) ;
}

// constructeur avec 2 points :

Méthode 01 : si on désigne le point bas et haut dans les paramètres de constructeur par
Point b à point bas et Point h à le point haut alors le constructeur s’écrit
Rectangle ( Point b , Point h ) {
gbase = b ;
longueurX = h.x – b.x ;
longueurY = h.y – b.y ;
}

5
 Méthode 02 : le cas générale (on ne sait pas quel est le point bas de point haut, dans cette
situation le point qui a l’abscisse la plus petite est le point bas et à gauche : la solution
s’écrit :
méthode 02 : écriture 01 // méthode 2 : écriture 02

Rectangle ( Point a , Point b ) { Rectangle ( Point a , Point b ) {

if (a.x<b.x ) { if (a.x<b.x ) {
gbase = a; gbase = a ;
longueurX = b.x – a.x ;
longueurY = b.y – a.y ; } else {
} else { gbase = b ;
gbase = b; }
longueurX = a.x – b.x ; longueurX = Math.abs(a.x – b.x) ;
longueurY = a.y – b.y ; longueurY = Math.abs(a.y – b.y) ;
}
}
}
}

5- Écrire une méthode get_Surface qui calcule la surface du rectangle.

class Rectangle {
Point gbase ;
double longueurX;
double longueurX;
Rectangle ( Point a , double x , double y ) {…….}
Rectangle ( Point a , Point b ) {………………….}
double get_Surface () {
return longueurX * longueurY ;
}
}

6- Écrire une méthode Deplacer qui déplace un rectangle en déplaçant le point en bas et à gauche,

class Rectangle {

Point gbase ;
double longueurX;
double longueurX;

Rectangle ( Point a , double x , double y ) {…….}

Rectangle ( Point a , Point b ) {………………….}
double get_Surface () {………………………….}

6
 // première méthode de deplacement
void deplacer ( Point a) {
gbase = a ;
}
// deuxieme méthode de deplacement
void deplacer (Point a) {
gbase. deplacer_Point (a) ;
}
}

7- Écrire une méthode Contains qui teste si un point donné (en paramètre) est à l'intérieur du rectangle.

class Rectangle {

Point gbase ;
double longueurX;
double longueurX;
Rectangle ( Point a , double x , double y ) {…….}
Rectangle ( Point a , Point b ) {………………….}
double get_Surface () {………………………….}
void deplacer (Point pos) {………………………}

boolean contain ( Point pt) {

if ((pt.x > gbase .x) &&( pt.x< gbase .x+longueurX ) && (pt.y > gbase .y ) && ( pt.y<gbase .y+longueurY) ) )
{
return true ;
} else {
return false ;
}
}
}

8- Définir une classe Dessin. Chaque objet de cette classe contient un tableau de rectangles dont la taille est
fixée à la construction de l'objet. Au départ, un dessin ne contient aucun rectangle.
class Dessin {
Rectangle [] Rec ;
int nbr ; // nombre de rectangle dans le dessin
// constructeur
Dessin (int taille) { // taille : taille de tableau des rectangle : Rectangle [] Rec ;
Rec = new Rectangle [taille] ;
nbr = 0 ;
}

7
 if (nbr != Rec.length) {
9- Écrire une méthode Add qui permet d'ajouter un rectangle à un dessin.
Rec [nbr] = r ;
class Dessin { nbr ++ ;

Rectangle [] Rec ; } else {

int nbr ; // nombre de rectangle dans le dessin System.out.println(“Dessin plein”);

// Dessin (int taille) {………………….} }

void Add (Rectangle r) {
if (nbr < Rec.length) {//ou // (la taille d’un tableau = nomtableau.length)
if (nbr = = Rec.length) {
Rec [nbr] = r ;
nbr ++ ; System.out.println(“Dessin plein”);

} else } else {
System.out.println(“Dessin plein”); Rec [nbr] = r ;
} nbr ++ ;
} }

10- Écrire une méthodes Surface pour la classe Dessin. La surface d'un dessin est la somme des surfaces de ses
rectangles même si ceux-ci se superposent.
class Dessin {
Rectangle [] Rec ;
int nbr ; // nombre de rectangle dans le dessin
Dessin (int taille) {………………….}
void Add (Rectangle r) {…………..}
double Surface() {
double somme = 0 ; // variable contient la somme de toutes les surfaces
for (i = 0 ; i< nbr ; i++ ) {
somme = somme + Rec[i]. get_Surface () ;
}
return somme ;
}
}

8
11- Écrire une méthodes Translate pour la classe Dessin. Translater un dessin consiste à déplacer chacun de ses
rectangles.
class Dessin {
Rectangle [] Rec ;
int nbr ; // nombre de rectangle dans le dessin
Dessin (int taille) {………………….}
void Add (Rectangle r) {….………..}
double Surface() { …………………}

void Translate (Point p){

for (int i = 0 ; i< nbr ; i++ ) {
Rec[i]. Deplacer(p) ;
}
}

l’instruction for … each : introduit à partir de la version 1.5 de JAVA , définie comme une nouvelle
instruction de contrôle adaptée aux collections, aux tableaux et aux chaînes , elle ne s’applique qu’à des
consultations de valeurs, et en aucun cas à des modifications.plus de détails en TD.
Essayer de tester cette instruction sous Eclipse !!!!!!! si votre eclipse est configuré avec une version moins
que 1.5 le complitateur ne connaît pas l’instruction alors pour résoudre le probleme :
Cliquer avec le boutton droite de la souris sur le nom-de-votre-projet à propriétes à java compiler : dans la
page à droite selectionner : configure workspace settings à changer la valeur de :Compiler compliance level
à la version 1.5 ou plus
Puis valider cliquer sur Apply puis apply . fermer eclipse tester à nouveau l’instruction iiiiiiiiih ça
marche..OK

Lecture au clavier :
Scanner lire = new Scanner (System.in);
String s = lire.next() ; // pour un mot terminé par un espace
String s = lire.nextLine (); // pour une chaine avec des espaces
char c= lire.next().charAt(0) ; // caractère position 0 si on saisie en clavier LMD c= L
char c= lire.next().charAt(2) ; // caractère position 2 si on saisie en clavier LMD c= D

Lecture d’un caractère :

try {
char c =(char) System.in.read(); // méthode renvoie un int
}
catch (Exception ex) {
}

9
 saisir une valeur double ou float au clavier : 1,5 ou 1.5 ?
Selon la zone de système d’exploitation : fr à 1,5 US : à 1.5
Pour modifier la localité on utilise l’instruction : lire.useLocale (Locale.US) ;
lire.useLocale (Locale.FRENCH) ;

Une méthode peut renvoyer un objet par exemple la méthode MaxSurface renvoie un objet de type
rectangle
Rectangle MaxSurface ( ) {
……………
return Rec[0];
}

Méthodes avec parametre dynamique version 1.5 de java ou plus

double calcule ( int … t ){

}
on peut appeler la méthode calcule par :
calcule () calcule (a) calcule (a,b) calcule(a,b,c)
Avec t[0] represente le premier paramètre a
Avec t[1] represente le deuxieme paramètre b
Avec t[2] represente le troisieme paramètre c
Et Ainsi de suite.

Objets identiques :
Maclasse m1 = new maclasse() ;
Maclasse m2 = m1 ;
m1 et m2 contiennent la même référence et pointent donc tous les deux sur le même objet .
un changement de m1 affecte m2.
Pour créer deux objet differents il faut que la classe implement l’interface Cloneable………

10
 Exercice 05 :
class Horloge{ void Format ( ) {

private byte Seconde, Minute, Heure ; System.out.println("L’heure est :" + Heure +": " + Minute +
" :" + Seconde );
//constructeur 01
}
Horloge ( ) {
public int getHeure ( ) { return Heure ;}
this. Seconde = 0;
public int getMinute () {return Minute ;}
this.Minute =0;
public int getSeconde () {return Seconde ;}
this.Heure = 0;
public void setHeure (byte Heure){ this.Heure =Heure; }
}
public void setMinute (byte Minute){ this.Minute=Minute; }
//constructeur 02
public void setSeconde (byte Seconde){ this. Seconde=Seconde;
Horloge (byte seconde, byte minute, byte heure) { }
this. Seconde = seconde; }// fin classe
this.Minute =minute;
this.Heure = heure; Remarque : on peut définir une méthode dont le nombre
} d’arguments est variable. Par exemple, si l’on définit une
méthode calcule avec l’en-tête suivant :
//constructeur 03 int calcule ( int … t) alors on peut faire les appels suivans
Horloge ( Horloge R) {
int a,b ;
this. Seconde = R.Seconde; calcule () ; // aucun argument
calcule (a) ; // un argument de type int
this.Minute =R.Minute; calcule (a, b) ; // deux arguments de type int
this.Heure =R.Heure; calcule (a, v,…….) ; // plusieurs arguments de type int

} avec : a désigne t[0]

boolean Heurevalide ( ){ b désigne t[1] ainsi de suite

if ((Seconde<60) && (Seconde>=0)&& La notation ... utilisée dans un tel contexte se nomme
(Minute<60)&& (Minute>=0)&& (Heure<24)&&
(Heure>=0)) { souvent "ellipse".
Exemple de constructeur 02 :
return true ;
} else return false;
Horloge (int seconde, int minute, int heure) :

} Horloge (int … t )

// la méthode Heurevalide s’écrit aussi Dans ce situation t[0] designe les seconde
boolean Heurevalide () { t[1] designe les minute
t[2] designe les heur
return ((Seconde<60) && (Seconde>=0)&&
(Minute<60)&& (Minute>=0)&& (Heure<24)&& la méthode s’écrit alors :
(Heure>=0)) ;
} Horloge (int … t ) {

int nombredeseconde (){ this. Seconde = t[0];

return 3600*Heure + 60*Minute + Seconde ; this.Minute = t[1];

} this.Heure = t[2] ;
}

11