Solution

/**
* Un Carré est un Rectangle particulier
* (Carré est une specialisation de Rectangle)
*/
public class Carré extends Rectangle {
/* Invariant de classe : largeur = longueur >=0 */
/**
* crée un carré de la dimension voulue
*
* @param côté longueur du côté
*/
public Carré(double côté) {
super(côté, côté);
}
/**
* Rôle : change la valeur du coté du carré courant
*
* @param c nouvelle valeur du coté
*/
public void changerCoté(double c) {
super.changerLargeur(c);
super.changerLongueur(c);
}
/**
* Rédéfinition de changerLargeur de Rectangle pour
* garantir l’invariant de la classe Carré
*/
public void changerLargeur(double l) {
this.changerCoté(l);
}
/**
* Rédéfinition de changerLongueur de Rectangle pour
* garantir l’invariant de la classe Carré
*/
public void changerLongueur(double L) {
this.changerCoté(L);
}
}
nov. 09, 16 15:26 Page 1/1Carré.java
Printed by Vincent Granet
mercredi novembre 09, 2016 1/9
/**
* Un Cercle est une Ellipse particulière
* (Cercle est une spécialisation d’Ellipse)
*/
public class Cercle extends Ellipse {
/* Invariant de classe : petitRayon = grandRayon >=0 */
/**
* crée un cercle de diamètre donné
*
* @param diamètre du cercle
*/
public Cercle(double diamètre) {
super(diamètre, diamètre);
}
/**
* Rôle : change la valeur du diamètre du Cercle courant
*
* @param c nouvelle valeur du diamètre
*/
public void changerDiamètre(double d) {
super.changerPetitRayon(d);
super.changerGrandRayon(d);
}
/**
* Rédéfinition de changerPetitRayon d’Ellipse pour
* garantir l’invariant de la classe Cercle
*/
public void changerPetitRayon(double pa) {
this.changerDiamètre(pa);
}
/**
* Rédéfinition de changerGrandRayon d’Ellipse pour
* garantir l’invariant de la classe Cercle
*/
public void changerGrandRayon(double ga) {
this.changerDiamètre(ga);
}
/*
* Rôle : renvoie la représentation sous forme d’une String de
* l’objet courant this
*/
public String toString() {
return "Cercle (" + petitRayon + ")";
}
}
nov. 09, 16 15:26 Page 1/1Cercle.java
Printed by Vincent Granet
2/9 mercredi novembre 09, 2016

/** une Ellipse est défini par son petit axe et son grand axe */
public class Ellipse extends Figure {
/* Invariant de classe : petitRayon et grandRayon >=0 */
/**
* grand axe
*/
protected double grandRayon;
/**
* petit axe
*/
protected double petitRayon;
/**
* crée une ellipse avec les dimension voulues
*
* @param g grand axe
* @param p petit axe
*/
public Ellipse(double g, double p) {
grandRayon = g;
petitRayon = p;
}
/**
* Rôle : @return surface de l’ellipse
*/
public double surface() {
return Math.PI * grandRayon * petitRayon;
}
/**
* Rôle : @return périmètre de l’ellipse
*/
public double périmètre() {
return Math.PI * Math.sqrt(2*(grandRayon*grandRayon + petitRayon*petitRa
yon));
}
/**
* Rôle : change la longueur du grand axe
*
* @param u nouvelle longueur
*/
public void changerGrandRayon(double ga) {
this.grandRayon = ga;
}
/**
* Rôle : change la longueur du petit axe
*
* @param u nouvelle largeur
*/
public void changerPetitRayon(double pa) {
this.petitRayon = pa;
}
/*
* Rôle : renvoie la représentation sous forme d’une String de
* l’objet courant this
*/
public String toString() {
return "Ellipse (" + petitRayon + "," + grandRayon + ")";
}
nov. 09, 16 15:26 Page 1/2Ellipse.java
Printed by Vincent Granet
mercredi novembre 09, 2016 3/9
}
nov. 09, 16 15:26 Page 2/2Ellipse.java
Printed by Vincent Granet
4/9 mercredi novembre 09, 2016

/*
* Classe abstraite Figure
*/
abstract public class Figure {
/**
* point d’origine de la figure
*/
protected Point origine;
/**
* Rôle : crée une figure dont l’origine est (0, 0)
*/
public Figure() {
origine = new Point();
}
/**
* Rôle : crée une figure dont l’origine est (x, y)
*
* @param x abscisse de l’origine
* @param y ordonnée de l’origine
*/
public Figure(Point p) {
origine = p;
}
/**
* Rôle : @return origine de la figure
*/
public Point origine() {
return origine;
}
/**
* Rôle : @return périmètre de la figure
*/
abstract public double périmètre();
/*
* Rôle : @return surface de la figure
*/
abstract public double surface();
}
nov. 09, 16 15:26 Page 1/1Figure.java
Printed by Vincent Granet
mercredi novembre 09, 2016 5/9
/**
* Callse Point : un point de l’espace cartésien à deux dimensions
*/
public class Point {
// abscisse
private double x;
// ordonnée
private double y;
/**
* Rôle : crée le point (a, b)
*
* @param a abscisse
* @param b ordonnée
*/
public Point(double a, double b) {
x = a;
y = b;
}
/**
* Rôle : crée le point (0, 0)
*/
public Point() {
x = y = 0;
}
/**
* Rôle : renvoie l’abcisse du point courant
* @return abscisse
*/
public double abscisse() {
return x;
}
/**
* Rôle : renvoie l’ordinnée du point courant
* @return ordonnée
*/
public double ordonnée() {
return y;
}
/**
* Rôle : @return représentation sous forme de chaîne de caractères
* de l’objet courant
*/
public String toString() {
return "(" + x + "," + y +")";
}
}
nov. 09, 16 15:26 Page 1/1Point.java
Printed by Vincent Granet
6/9 mercredi novembre 09, 2016

/**
* La classe Rectangle
*
*/
public class Rectangle extends Figure {
/* Invariant de classe : largeur et longueur >=0 */
/**
* longueur du rectangle
*/
protected double longueur;
/**
* largeur du rectangle
*/
protected double largeur;
/**
* Rôle : crée un rectangle avec les dimension voulues
*
* @param L longueur
* @param l largeur
*/
public Rectangle(double L, double l) {
longueur = L;
largeur = l;
}
/**
* Rôle : @return surface du rectangle
*/
public double surface() {
return longueur*largeur;
}
/**
* @return périmètre du rectangle
*/
public double périmètre() {
return 2 * (longueur + largeur);
}
/**
* Rôle : renvoie la représentation d’un rectangle sous la forme d’une
* chaîne de caractères.
* @return String
*/
public String toString() {
String bord = "+";
String intérieur = "|";
/* fabriquer une ligne de bord et une intérieure */
for(int i = 0; i< (int) longueur; i++) {
bord+="−−";
intérieur+=" ";
}
bord+="+";
intérieur+="|\n";
/* fabriquer le rectangle à partir des 2 lignes précédentes */
String s = bord + "\n";
for(int i = 0; i < (int) largeur; i++)
s+=intérieur;
/* renvoyer le rectangle */
return s+bord;
}
nov. 09, 16 15:26 Page 1/2Rectangle.java
Printed by Vincent Granet
mercredi novembre 09, 2016 7/9
/**
* Rôle : change la longueur du rectangle
*
* @param L nouvelle longueur
*/
public void changerLongueur(double L) {
longueur = L;
}
/**
* Rôle : change la largeur du rectangle
*
* @param l nouvelle largeur
*/
public void changerLargeur(double l) {
largeur = l;
}
}
nov. 09, 16 15:26 Page 2/2Rectangle.java
Printed by Vincent Granet
8/9 mercredi novembre 09, 2016

import java.util.Random;
public class Test {
public static void main(String [] args) {
Random r = new Random();
Figure [] tf = new Figure[5];
int lgMax = 6;
// créer les Figures : application du polymorphisme
for (int i=0; i<tf.length; i++) {
switch (r.nextInt(4)) {
case 0 :
tf[i] = new Rectangle(r.nextInt(lgMax),r.nextInt(lgMax));
break;
case 1 :
tf[i] = new Carré(r.nextInt(lgMax));
break;
case 2 :
tf[i] = new Ellipse(r.nextInt(lgMax),r.nextInt(lgMax));
break;
case 3 :
tf[i] = new Cercle(r.nextInt(lgMax));
break;
}
}
// Afficher le tableau : application de la liaison dynamique
for (Figure f : tf)
System.out.println(f);
}
}
nov. 09, 16 15:26 Page 1/1Test.java
Printed by Vincent Granet
mercredi novembre 09, 2016 9/9