Commit 73682abb authored by Benjamin Bonnabaud's avatar Benjamin Bonnabaud
Browse files

exemple point2D

parent afa7309c
/**
* Point 2D, representé par deux coordonnées entières.
* @author Mathieu Chabanas, modifications Nicolas Castagné
* 2015 -> 2017
* Attention : seule la dernière version Point3 de la classe est "propre"
*/
class Point0 {
// les attributs : en haut de la classe
/** Abscisse du point */
int x;
/** Ordonnee du point */
int y;
// les méthodes
/**
* Translate le point a la position (x+dx, y+dy).
* @param dx deplacement selon la coordonnee x
* @param dy deplacement selon la coordonnee y
*/
void translate(int dx, int dy) {
this.x += dx;
this.y += dy;
}
}
/**
* Point 2D, representé par deux coordonnées entières.
* @author Mathieu Chabanas, modifications Nicolas Castagné
* 2015 -> 2017
* Attention : seule la dernière version Point3 de la classe est "propre"
*/
// Ajout d'un INVARIANT DE CLASSE: y > 0 (why not?)
public class Point1 {
public int x;
private int y; // attribut PRIVE
/**
* Accesseur (get): accède en lecture à l'ordonnée du point.
* @return la valeur de y
*/
public int getY() {
return this.y; // ou return y; => le "this" est optionnel
}
/**
* Mutateur (set): modifie l'ordonnée du point.
* @throws IllegalArgumentException si la nouvelle ordonnée ne vérifie
* pas l'invariant this.y >= 0
*/
public void setY(int y) {
if (y <= 0) {
throw new IllegalArgumentException("Invariant sur y non respecte");
}
this.y = y; // this obligatoire pour level l'ambiguité
// entre paramètre y de la méthode et attribut y
}
public void translate(int dx, int dy) {
this.x += dx; // ou x+=dx : le this est optionnel
this.y += dy; // danger?
}
// SURCHARGE de la methode : même nom, paramètre différents
public void translate(int dx) {
translate(dx, 0); // en fait this.translate(dx, 0)
}
}
/**
* Point 2D, representé par deux coordonnées entières.
* @author Mathieu Chabanas, modifications Nicolas Castagné
* 2015 -> 2017
* Attention : seule la dernière version Point3 de la classe est "propre"
*/
// Mise en place des CONSTRUCTEURS
// et de la méthode "standard" en java String toString()
public class Point2 {
public int x;
private int y;
/** Construit un point de coordonnées (a,y). */
public Point2(int a, int y) {
x = a;
setY(y); // pourquoi pas this.y = y ?
}
// => on parle de CONSTRUCTEUR PAR COPIE, à partir du point p existant
/** Construit un point de même coordonnées que p. */
public Point2(Point2 p) {
this.x = p.x;
this.y = p.y; // dangeureux ou non? utiliser setY?
}
// constructeur sans paramètre => on parle de CONSTRUCTEUR PAR DEFAUT
/** Construit un point de coordonnées (0,0). */
public Point2() {
this(0, 0); // réinvoque un autre constructeur
}
public int getY() {
return this.y;
}
public void setY(int y) {
if (y <= 0) {
throw new IllegalArgumentException("Invariant sur y non respecte");
}
this.y = y;
}
public void translate(int dx, int dy) {
x += dx;
setY(y + dy);
}
/**
* Retourne représentation de l'objet sous forme de chaine de
* caracteres: "(x,y)"
*/
@Override
public String toString() {
return new String("(" + x + ", " + y + ")");
}
}
/**
* Point 2D, representé par deux coordonnées entières.
* @author Mathieu Chabanas, modifications Nicolas Castagné
* 2015 -> 2017
* Attention : seule la dernière version Point3 de la classe est "propre"
*/
// Mise en place de la méthode equals()
public class Point3 {
// "vraie classe Java bien écrite" x serait aussi private
public int x;
private int y;
/** Construit un point de coordonnées (a,y). */
public Point3(int a, int y) {
x = a;
setY(y); // pourquoi pas this.y = y ?
}
// => on parle de CONSTRUCTEUR PAR COPIE, à partir du point p existant
/** Construit un point de même coordonnées que p. */
public Point3(Point3 p) {
this.x = p.x;
this.y = p.y; // dangeureux ou non? utiliser setY?
}
// constructeur sans paramètre => on parle de CONSTRUCTEUR PAR DEFAUT
/** Construit un point de coordonnées (0,0). */
public Point3() {
this(0, 0); // réinvoque un autre constructeur
}
public int getY() {
return this.y;
}
public void setY(int y) {
if (y <= 0) {
throw new IllegalArgumentException("Invariant sur y non respecte");
}
this.y = y;
}
public void translate(int dx, int dy) {
x += dx;
setY(y + dy);
}
/**
* Retourne représentation de l'objet sous forme de chaine de
* caracteres: "(x,y)"
*/
@Override
public String toString() {
return new String("(" + x + ", " + y + ")");
}
/**
* Indique si l'objet o est "égal" à l'instance.
* Ici cela signifie qu'ils sont du même type (Point3)
* et de même coordonnées.
*/
@Override
public boolean equals(Object o) {
return o instanceof Point3
&& ((Point3) o).x == this.x
&& ((Point3) o).y == this.y;
}
}
public class Segment {
private Point3 p1;
private Point3 p2;
/* construit le segment [ (0,0) , (1,1) ] */
public Segment() {
this.p1 = new Point3(0,0);
this.p2 = new Point3(1,1);
}
public Segment(Point3 p1, Point3 p2) {
this.p1 = p1; // ou new Point3(p1); ???
this.p2 = p2; // ou new Point3(p2); ???
}
public Segment(int x1, int y1, int x2, int y2) {
this(new Point3(x1, y1), new Point3(x2, y2));
}
/* construit le segment [ (0,0) , (x2,y2) ] */
public Segment(int x2, int y2) {
this(new Point3(0, 0), new Point3(x2, y2));
}
public Segment(Segment other) {
this(new Point3(other.p1), new Point3(other.p2));
}
// euh... est-ce legitime ?
public Point3 getP1() {
return this.p1;
}
// euh... est-ce legitime ?
public Point3 getP2() {
return this.p2;
}
public void setP1(Point3 p) {
this.p1 = p; // ou bien : this.p1 = new Point3(p1) ; ???
}
public void setP2(Point3 p) {
this.p2 = p; // ou bien : this.p1 = new Point3(p2) ; ???
}
public double getLength() {
return Math.sqrt( (p2.getY() - p1.getY()) * (p2.getY() - p1.getY())
- (p2.x - p1.x) * (p2.x - p1.x) ) ;
}
public void translate(int dx, int dy) {
p1.translate(dx, dy);
p2.translate(dx, dy);
}
@Override
public String toString() {
return new String(" Segment [" + p1 + " , " + p2 + "]");
}
@Override
public boolean equals(Object o) {
return o instanceof Segment
&& ((Segment) o).p1.equals(this.p1)
&& ((Segment) o).p2.equals(this.p2);
}
}
public class TestPoint0 {
public static void main(String[] args) {
// un exemple de boucle + variable
for (int i = 0; i < 5; i++) {
System.out.print(i);
}
double pi = 3.1415927;
System.out.println("; pi = " + pi);
// creation/manipulation d'objets
Point0 p0 = null;
p0 = new Point0();
p0.x = -2;
p0.y = 1;
System.out.println("p0: (" + p0.x + "," + p0.y + ")");
Point0 p1 = new Point0();
p1 = p0;
p1.translate(2, 2);
System.out.print("Maintenant, p0 vaut: ");
System.out.println("(" + p0.x + "," + p0.y + ")");
}
}
public class TestPoint1 {
public static void main(String[] args) { //throws Exception {
Point1 p0 = new Point1();
p0.x = -2;
// p0.y = 2; // Impossible : y est privé
p0.setY(2);
System.out.println("p0 (1): (" + p0.x + "," + p0.getY() + ")");
try {
p0.setY(-3);
} catch (IllegalArgumentException e) {
System.out.println("Exception attrapée: " + e);
System.out.println("mais pas de traitement ici, on continue");
}
System.out.println("p0 (2): (" + p0.x + "," + p0.getY() + ")");
p0.setY(-3); // insistons!
System.out.println("p0 (3): (" + p0.x + "," + p0.getY() + ")");
// p0 est-il affiche?
}
}
public class TestPoint2 {
public static void main(String[] args) throws Exception {
Point2 p0 = new Point2();
Point2 p1 = new Point2(-2, 2);
Point2 p2 = new Point2(p0);
System.out.println("p0: " + p0.toString());
System.out.println("p1: " + p1);
System.out.println("p2: " + p2);
p2.translate(10, 10);
System.out.println("p0: " + p0.toString());
System.out.println("p2: " + p2);
// p1.translate(0, -6);
// System.out.println(p1);
}
}
public class TestPoint3 {
public static void main(String[] args) throws Exception {
Point3 p0 = new Point3(-2, 2);
Point3 p1 = p0; // copie de p0
Point3 p2 = new Point3(p0); // p2 et p0 réfèrent le même objet
System.out.println("p0 : " +p0.toString());
System.out.println("p1 : " + p1); // toString() optionnel :
System.out.println("p2 : " + p2); // Java l'appelle tout seul !
// comparaison d'objets: == vs equals
String res = new String("avec == p0 et p1 sont: ");
if (p0 == p1)
res = res + "identiques";
else
res = res + "differents";
System.out.println(res);
res = new String("avec == p0 et p2 sont: ");
if (p0 == p2)
res = res + "identiques";
else
res = res + "differents";
System.out.println(res);
res = new String("avec equals p0 et p2 sont: ");
if (p0.equals(p2))
res = res + "identiques";
else
res = res + "differents";
System.out.println(res);
}
}
public class TestSegment {
public static void main(String[] args) {
Point3 p0 = new Point3(1, 1);
Point3 p1 = new Point3(2, 2);
Point3 p2 = new Point3(4, 3);
Segment s1 = new Segment(p0, p1);
Segment s2 = new Segment(p1, p2);
System.out.println("s1 " + s1);
System.out.println("s2 " + s2);
p1.translate(3,3);
System.out.println("Apres translation de p1");
System.out.println("s1 " + s1);
System.out.println("s2 " + s2);
s1.translate(3,3);
System.out.println("Apres translation de s1");
System.out.println("s1 " + s1);
System.out.println("s2 " + s2);
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment