Introduction aux classes

Classe

Une classe est un modèle qui définit les objets d'un type. Une classe comprend des variables et des méthodes. Chaque objet de ce type possède toutes les variables d'instance et peut utiliser toutes les méthodes déclarées dans la classe.

Les valeurs des variables d'instance d'un objet représentent son état. La manière dont l'objet réagit aux applications des méthodes (messages) représente son comportement.

Problème : modéliser le concept de point

Analyse

Propriétes (le point lui-même ne sera pas modifié) :

• coordonnée x
• coordonnée y
• quelle est la distance d'un autre point
• quelle est la dimension (2, 3, ?)
• affichage (représentation textuelle ou graphique
• distance à un plan (???)

Opérations :

• construction d'un point
• symétrie selon l'axe x
• symétrie selon l'axe y
• déplacer à une nouvelle position
• rotation d'un angle autour du point d'origine

Nous allons nous limiter aux points dans un plan.

Représentation des points dans la mémoire

• nous allons représenter chaque point comme deux valeurs de type double
• d'autres représentations possibles

Nommons ces propriétés et opérations et déterminons les types des arguments et des valeurs de retour.

• getX() retourne une valeur de type double
• getY() retourne une valeur de type double
• distance(Point p) retourne une valeur de type double
• dimension() retourne une valeur de type int
• toString() retourne une valeur de type String
• distance(Plan p) retourne une valeur de type double
• Point(double x, double y)
• symetrieX()
• symetrieY()
• deplacer(double tr_x, double tr_y)
• rotation(double angle)

Code de la classe Point

public class Point {
  private double x, y;       // chaque objet point possède deux variables d'instance : x et y

  public Point(double x1, double y1) {    // l'en-tête de la méthode
    x = x1;                     // le corps de
    y = y1;                     // la méthode
  }
  public double getX(){
    return x;
  }

  public double getY(){
    return y;
  }

  public double distance(Point p) {
    return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
  }

  public int dimension(){
    return 2;
  }

  public String toString(){
    return "(" + x + "," + y + ")";
  }
  public void symetrieX(){
    y = -y;
  }

  public void symetrieY(){
    x = -x;
  }

  public void deplacer(double tr_x, double tr_y){
    x = x + tr_x;
    y = y + tr_y;
  }

  public void rotation(double angle){
    angle = (float)Math.toRadians((double)angle);
    double xtemp;
    xtemp = (x * (float)Math.cos(angle)) - (y * (float)Math.sin(angle));
    y = (x * (float)Math.sin(angle)) + (y * (float)Math.cos(angle));
    x = xtemp;
  }
}

Un petit test de la classe Point

public class TestPoint {

  public static void main(String[] args) {
    Point p1 = new Point(1, 2);
    Point p2 = new Point(1, -2);

    System.out.println("Point p1 est " + p1.toString());
    System.out.println("Point p2 est " + p2.toString());

    System.out.println("La coordonnée x du point p1 : " + p1.toString() + " est " + p1.getX());

    System.out.println("Distance entre p1 : " + p1.toString() + " et p2 : "
        + p2.toString() + " = " + p1.distance(p2));

    System.out.println("p1 avant la rotation : " + p1.toString());
    p1.rotation(90);
    System.out.println("p1 après la rotation : " + p1.toString());
  }

}

Compilation et exécution

javac Point.java TestPoint.java
java TestPoint

Point p1 est (1.0,2.0)
Point p2 est (1.0,-2.0)
La coordonnée x du point p1 : (1.0,2.0) est 1.0
Distance entre p1 : (1.0,2.0) et p2 : (1.0,-2.0) = 4.0
p1 avant la rotation : (1.0,2.0)
p1 après la rotation : (-2.0,1.0)

Explications du code

• la méthode main crée plusieurs objets. En plus des objets définis par le programmeur, elle crée trois objets de flux qu'elle associe aux périphériques
  • System.in représente le flux d'entrée standard, en général, le clavier
  • System.out représente le flux de sortie standard, en général, l'écran
  • System.err représente le flux d'erreur standard, en général, l'écran
• comment trouver la classe System et ses ressources (méthodes, objets, ...) ?
• la documentation de toutes les classes est disponible en ligne : http://java.sun.com/javase/6/docs/api/
• System.out est un objet et println("Point p1 est " + p1.toString()) est le message lui envoyé
• p1 est un objet et toString() est le message lui envoyé
• la notation objet.méthode(arguments) s'applique aux variables objets, c.-à-d. aux variables créées comme des instances de classe
• l'en-tête de la méthode main est toujours public static void main(String[] args)
• void est utilisé pour indiquer que la méthode ne retourne aucune valeur

Essayons d'utiliser la classe Point de la librairie Java

Bonnes nouvelles

• les méthodes getX(), getY(), toString(), distance(Point2D) et le conctructeur Point() existent déjà
• la méthode deplacer() existe sous le nom translate

Mauvaises nouvelles

• les points sont représentés comme une paire d'entiers
• les méthodes symetrieX(), symetrieY(), rotation(double) et dimension() n'existent pas

Pour régler le premier problème, remplaçons la classe Point par Point2D.Double.

import java.awt.geom.Point2D;
public class Test2Point {

  public static void main(String[] args) {
    Point2D p1 = new Point2D.Double(1, 2);
    Point2D p2 = new Point2D.Double(1, -2);

    System.out.println("Point p1 est " + p1.toString());
    System.out.println("Point p2 est " + p2.toString());

    System.out.println("La coordonnée x du point p1 : " + p1.toString() + " est " + p1.getX());

    System.out.println("Distance entre p1 : " + p1.toString() + " et p2 : "
        + p2.toString() + " = " + p1.distance(p2));

    System.out.println("p1 avant la rotation : " + p1.toString());
    //p1.rotation(90);
    System.out.println("p1 après la rotation : " + p1.toString());
  }

}

Pour régler le deuxième problème, nous allons créer une nouvelle classe étant une extension de la classe Point2D.Double.

import java.awt.geom.Point2D;
public class MonPoint extends Point2D.Double {

  public MonPoint(double x1, double y1){
    super(x1, y1);
  }

  public int dimension(){
    return 2;
  }

  public void symetrieX(){
    y = -y;
  }

  public void symetrieY(){
    x = -x;
  }

  public void rotation(double angle){
    angle = Math.toRadians(angle);
    double xtemp;
    xtemp = (x * Math.cos(angle)) - (y * Math.sin(angle));
    y = (x * Math.sin(angle)) + (y * Math.cos(angle));
    x = xtemp;
  }

}

Un test de cette classe

import java.awt.geom.Point2D.Double;
public class Test3Point {

  public static void main(String[] args) {
    MonPoint p1 = new MonPoint(1, 2);
    MonPoint p2 = new MonPoint(1, -2);

    System.out.println("Point p1 est " + p1.toString());
    System.out.println("Point p2 est " + p2.toString());

    System.out.println("La coordonnée x du point p1 : " + p1.toString() + " est " + p1.getX());

    System.out.println("Distance entre p1 : " + p1.toString() + " et p2 : "
        + p2.toString() + " = " + p1.distance(p2));

    System.out.println("p1 avant la rotation : " + p1.toString());
    p1.rotation(90);
    System.out.println("p1 après la rotation : " + p1.toString());
  }

}

Point p1 est Point2D.Double[1.0, 2.0]
Point p2 est Point2D.Double[1.0, -2.0]
La coordonnée x du point p1 : Point2D.Double[1.0, 2.0] est 1.0
Distance entre p1 : Point2D.Double[1.0, 2.0] et p2 : Point2D.Double[1.0, -2.0] = 4.0
p1 avant la rotation : Point2D.Double[1.0, 2.0]
p1 après la rotation : Point2D.Double[-2.0, 1.0000000000000002]