Skip to content

L3.PC Informatique (Cours)

Cours de Java

Examen oral

Exemple: la classe Polaire

définition de la classe Polaire et utilisation

package polaire;

/** La classe Polaire permet de travailler avec des coordonnées polaires

 * dans le plan (r, theta).
 *
 * Attention: theta est en degrées.
 *
 * @author gmonard
 * @version 2009-2010
 */
public class Polaire
{
   /* attributs */
   /* pas de javadoc publique pour les attributs private */
   /* par contre on peut mettre des commentaires pour soi ... */

   /** coordonnées cartésiennes x

    *
    * x = r cos(theta)
    */
   private double x;   /* coordonnees cartésiennes x, y */

   /** coordonnées cartésiennes y

    * 
    * y = r sin(theta)
    */
   private double y;

   /* constructeurs */
   /** Constructeur vide de Polaire: correspond à l'origine O du repère

    *
    */
   public Polaire()
   {
      this.x = 0.0;
      this.y = 0.0;
   }

   /** Constructeur de Polaire à partir d'un point P

    * @param r la distance à l'origine repère
    * @param degrees l'angle entre l'abcisse des x et la droite passant
    *              par P et l'origine du repère. En degrées.
    */
   public Polaire(double r, double degrees)
   {
      double radians;
      /* conversion de degree en radians */
      radians = degreesEnRadians(degrees);
      this.x = r * Math.cos(radians);
      this.y = r * Math.sin(radians);
   }

   /* accesseurs */
   /** accesseur de x

    *
    * @return la projection du point P sur l'axe des x
    */
   public double getX()
   {
      return this.x;
   }

   /** accesseur de y

    * 
    * @return la projection du point P sur l'axe des y
    */
   public double getY()
   {
      return this.y;
   }

   /** accesseur de r

    *
    * @return la distance entre P et l'origine du repère
    */
   public double getR()
   {
      return Math.sqrt(this.x * this.x + this.y * this.y);
   }

   /** accesseur de theta

    *
    * @return l'angle entre l'axe des x et la droite (OP) en degrées
    */
   public double getTheta()
   {
      double degrees;
      double radians;
      radians = Math.atan2(this.y, this.x);
      degrees = radiansEnDegrees(radians);
      return degrees;
   }

   /* mutateurs */
   /** Change la distance à l'origine

    *
    * @param r la nouvelle distance
    */
   public void setR(double r)
   {
      if (r < 0.)
      {
         System.out.printf("Attention: probleme dans setR()\n");
         System.out.printf("   r doit être positif ou nul\n");
         System.out.printf("   ici, r vaut %f\n", r);
         System.out.printf("=> r est mis à zéro par défaut\n");
         r = 0.;
      }
      double degrees;
      double radians;
      degrees = this.getTheta();
      radians = degreesEnRadians(degrees);
      this.x = r * Math.cos(radians);
      this.y = r * Math.sin(radians);
   }

   /** Change l'angle

    *
    * @param degrees le nouvel angle
    */
   public void setTheta(double degrees)
   {
      double radians;
      double r;
      radians = degreesEnRadians(degrees);
      r = this.getR();
      this.x = r * Math.cos(radians);
      this.y = r * Math.sin(radians);
   }

   /** Change les coordonnees du point

    *
    * @param r la nouvelle distance
    * @param degrees le nouvel angle
    */
   public void setNouvellesCoord(double r, double degrees)
   {
      double radians;
      /* conversion de degree en radians */
      radians = degreesEnRadians(degrees);
      this.x = r * Math.cos(radians);
      this.y = r * Math.sin(radians);
   }

   /* methodes */
   /** distance entre le point courant et un autre point (méthode d'objet)

    *
    * @param autrePoint l'autre point en coordonnées polaires
    * @return la distance entre les deux points
    */
   public double distance(Polaire autrePoint)
   {
      double dx;
      double dy;
      dx = autrePoint.getX() - this.getX();
      dy = autrePoint.getY() - this.getY();
      return Math.sqrt(dx * dx + dy * dy);
   }

   /** distance entre deux points (méthode statique)

    *
    * @param point1 le premier point en coordonnées polaires
    * @param point2 le deuxième point en coordonnées polaires
    * @return la distance entre les deux points
    */
   public static double distance(Polaire point1, Polaire point2)
   {
      double dx;
      double dy;
      dx = point2.getX() - point1.getX();
      dy = point2.getY() - point1.getY();
      return Math.sqrt(dx * dx + dy * dy);
   }

   /** methode d'affichage du point (utilise par println)

    *
    * @return la chaîne de caractères caractéristique du point P
    */
   public String toString()
   {
      return String.format("Point (%f, %f) = (%f, %f)",
              this.getR(), this.getTheta(),
              this.getX(), this.getY());
   }

   /* methodes statiques */
   private static double degreesEnRadians(double angle)
   {
      return angle / 180.0 * Math.PI;
   }

   private static double radiansEnDegrees(double angle)
   {
      return angle / Math.PI * 180.0;
   }

   /** méthode main qui sert de test pour la classe Polaire

    *
    * @param args non utilisé ici
    */
   public static void main(String[] args)
   {
      /* typage */
      Polaire p1;
      Polaire p2;

      /* corps du programme */
      p1 = new Polaire();
      p2 = new Polaire(2, 30.);

      System.out.print("p1: ");
      System.out.println(p1);    // merci la méthode toString() !
      System.out.printf("p2: %s\n", p2);

      System.out.printf("distance entre p1 et p2: %f\n",
              Polaire.distance(p1, p2));
      System.out.println();      // ligne blanche

      p1.setR(1.);
      p1.setTheta(30.);
      System.out.printf("p1: %s\n", p1);
      System.out.printf("distance entre p1 et p2: %f\n",
              Polaire.distance(p1, p2));
      System.out.println();      // ligne blanche

      p2.setR(-2.);
      System.out.printf("p2: %s\n", p2);

   }
}