001 /**
002 * <code>Point</code> definit une classe point mathematique dans un
003 * plan qui peut est dans un repere cartesien.<BR>
004 * Un point peut etre translate. Sa distance par rapport a un autre
005 * point peut etre obtenue.
006 *
007 * @author <a href="mailto:garion@supaero.fr">Christophe Garion</a>
008 * @version 1.0
009 */
010 class Point {
011 private double x;
012 private double y;
013
014 /**
015 * Cree une nouvelle instance de <code>Point</code>.
016 *
017 * @param x_ un <code>double</code> representant l'abscisse du
018 * point a creer
019 * @param y_ un <code>double</code> representant l'ordonnee du
020 * point a creer
021 */
022 public Point(double x_, double y_) {
023 this.x = x_;
024 this.y = y_;
025 }
026
027 /**
028 * <code>getX</code> retourne l'abscisse du point
029 *
030 * @return un <code>double</code> qui est l'abscisse du point
031 */
032 public double getX() {
033 return this.x;
034 }
035
036 /**
037 * <code>getY</code> retourne l'ordonnee du point
038 *
039 * @return un <code>double</code> qui est l'ordonnee du point
040 */
041 public double getY() {
042 return this.y;
043 }
044
045 /**
046 * <code>setX</code> permet de modifier la valeur de l'abscisse
047 * du point.
048 *
049 * @param x_ un <code>double</code> qui est la nouvelle abscisse
050 */
051 public void setX(double x_) {
052 this.x = x_;
053 }
054
055 /**
056 * <code>setY</code> permet de modifier la valeur de l'ordonnee
057 * du point.
058 *
059 * @param y_ un <code>double</code> qui est la nouvelle ordonnee
060 */
061 public void setY(double y_) {
062 this.y = y_;
063 }
064
065 /**
066 * <code>translater</code> permet de translater le point.
067 *
068 * @param dx un <code>double</code> qui represente l'abscisse du
069 * vecteur de translation
070 * @param dy un <code>double</code> qui represente l'ordonnee du
071 * vecteur de translation
072 */
073 public void translater(double dx, double dy) {
074 this.x = this.x + dx;
075 this.y = this.y + dy;
076 }
077
078 /**
079 * <code>afficher</code> permet d'afficher les coordonnees du point.
080 *
081 */
082 public void afficher() {
083 System.out.println(this);
084 }
085
086 /**
087 * <code>toString</code> renvoie un objet de type <code>String</code>
088 * qui represente une chaine de caracteres representant le point.
089 *
090 * <p> Nous verrons plus tard (cf. cours sur l'heritage) que
091 * cette methode nous permet d'utiliser un objet comme un type
092 * primitif et d'ecrire par exemple <code>System.out.println("Le
093 * point est : " + p)</code> ou <code>p</code> est une poignee
094 * sur un objet de type <code>Point</code>.
095 *
096 * @return un objet de type <code>String</code> representant
097 * le point. Pour un point de coordonnees (2,3), cet objet
098 * representera la chaine <code>(2,3)</code>.
099 */
100 public String toString() {
101 return ("(" + this.x + "," + this.y + ")");
102 }
103
104 /**
105 * <code>distance</code> permet de calculer la distance entre deux
106 * points.
107 *
108 * @param p un <code>Point</code> qui est l'autre point pour calculer
109 * la distance
110 * @return un <code>double</code> qui est la distance entre les deux
111 * point
112 */
113 public double distance(Point p) {
114 return (Math.sqrt(((this.x - p.x) * (this.x - p.x)) +
115 ((this.y - p.y) * (this.y - p.y))));
116 }
117
118 /**
119 * <code>lt</code> permet de dire si un point est strictement plus
120 * petit qu'un autre (au sens lexicographique).
121 *
122 * @param p le <code>Point</code> a comparer
123 * @return un <code>boolean</code> qui est <code>true</code> ssi
124 * le point courant est strictement plus petit que p
125 */
126 public boolean lt(Point p) {
127 if (this.x != p.x) {
128 return (this.x < p.x);
129 } // end of if (this.x != p.x)
130 else {
131 return (this.y < p.y);
132 } // end of if (this.x != p.x)else
133 }
134
135 /**
136 * <code>ge</code> permet de dire si un point est plus
137 * grand qu'un autre (au sens lexicographique).
138 *
139 * @param p le <code>Point</code> a comparer
140 * @return un <code>boolean</code> qui est <code>true</code> ssi
141 * le point courant est plus grand que p
142 */
143 public boolean ge(Point p) {
144 return (!lt(p));
145 }
146
147 /**
148 * <code>gt</code> permet de dire si un point est strictement plus
149 * grand qu'un autre (au sens lexicographique).
150 *
151 * @param p le <code>Point</code> a comparer
152 * @return un <code>boolean</code> qui est <code>true</code> ssi
153 * le point courant est strictement plus grand que p
154 */
155 public boolean gt(Point p) {
156 return (p.lt(this));
157 }
158
159 /**
160 * <code>le</code> permet de dire si un point est plus
161 * petit qu'un autre (au sens lexicographique).
162 *
163 * @param p le <code>Point</code> a comparer
164 * @return un <code>boolean</code> qui est <code>true</code> ssi
165 * le point courant est plus petit que p
166 */
167 public boolean le(Point p) {
168 return (!p.lt(this));
169 }
170 }
|