Éléments de programmation objet

Méthodes

Principe

Programmation objet :

• mettre en valeur les fonctionnalités
• masquer les détails de l’implémentation

Au lieu d’accéder aux champs directement, on utilise des méthodes

Méthode

• Fonction ajoutée dans la déclaration de la classe (mais sans le mot-clef static)
• Appelé à partir d’une référence d’un objet de la classe (objet.méthode(paramètres))
• Elle a donc accès, via cette référence au champs de l’objet
• Cette référence en appelé this

Exemple:

class Vecteur {
  double x,y;
  Vecteur(double x, double y) {
    this.x = x;
    this.y = y;
  }
  double module() {
    return Math.sqrt(this.x*this.x+this.y*this.y);
  }
  double argument() {
    return Math.atan2(this.y,this.x);
  }
}

Types de méthodes

• Accesseurs : méthodes qui accèdent aux champs mais sans les modifier (méthode en général sans paramètre mais ça n’est pas obligatoire)
• Modificateurs : méthodes qui modifient les champs (renvoient en général void mais ça n’est pas obligatoire)

Exemple:

class Voiture {
  String couleur;
  String marque;
  String modele;
  Voiture(String couleur, String marque, String modele) {
    this.couleur=couleur;
    this.marque=marque;
    this.modele=modele;
  }
  boolean estBlanche() {
    return this.couleur.equals("blanc");
  }
  void repeint(String couleur) {
    this.couleur = couleur;
  }
}

Appel de méthode

Pour appeler une méthode, la syntaxe est objet.méthode(paramètres)

Ce sont les champs de l’objet réféencé par objet qui sont utilisés et/ou modifiés par la méthode

En cas d’appel de méthode sur la référence null, la machine virtuelle lève une exception NullPointerException (l’équivalent en plus propre de Segmentation Fault).

Exemple:

class Prog {
  public static void main(String[] args) {
    Voiture voiture = new Voiture("blanc","Renault","4L");
    if (voiture.estBlanche())
      System.out.println("La voiture est blanche");
    else
      System.out.println("La voiture n'est pas blanche");
    voiture.repeint("blanc");
    if (voiture.estBlanche())
      System.out.println("La voiture est blanche");
    else
      System.out.println("La voiture n'est pas blanche");
  }
}

Méthode toString

Quand on affiche un objet ou que l’on le concatène avec l’opérateur +, l’objet est converti en chaîne en appelant la méthode toString(). Elle doit être public (pour indiquer que la machine virtuelle a le droit de l’utiliser, comme le main).

class Voiture {
  String couleur;
  String marque;
  String modele;
  Voiture(String couleur, String marque, String modele) {
    this.couleur=couleur;
    this.marque=marque;
    this.modele=modele;
  }
  boolean estBlanche() {
    return this.couleur.equals("blanc");
  }
  void repeint(String couleur) {
    this.couleur = couleur;
  }
  public String toString() {
    return this.marque+" "+this.modele+" de couleur "+this.couleur;
  }
}

class Prog {
  static String excesDeVitesse(Voiture v, int vitesse) {
    return v+" à "+vitesse+" km/h";
  }
  public static void main(String[] args) {
    Voiture voiture = new Voiture("noire","Peugeot","RCZ");
    System.out.println(voiture);
    System.out.println(excesDeVitesse(voiture,254));
  }
}

Partie publique, partie privée

Pour séparée les fonctionalités de l’implémentation, nous disposons de deux modificateurs:

• private pour dire que seule « la classe » peut utiliser
• public pour dire que tous peuvent utiliser

Il y a également deux niveaux intermédiaires. L’un sera vu en même temps que la notion de paquetage et l’autre en même temps que la notion d’héritage.

Dorénavant, tout élément d’une classe devra être soit privé soit public.

Comme les classes seront toutes publiques, elles devront être chacune dans un fichier de même nom terminé par .java.

Privé : partie implémentation

On déclare privé ce qui sert à l’implémentation des fonctionalités

• les champs
• les méthodes utilitaires
• les fonctions utilitaires

Exemple :

public class GeometrieDuCercle {
  private double rayon;
  public GeometrieDuCercle(double rayon) {
    this.rayon=rayon;
  }
  private double r2() {
    return rayon*rayon;
  }
  private double r3() {
    return rayon*rayon*rayon;
  }
  public double diametre() {
    return 2*rayon;
  }
  public double circonference() {
    return Math.PI*diametre();
  }
  public double aire() {
    return Math.PI*r2();
  }
  public double aireSphere() {
    return 4*Math.PI*r2();
  }
  public double volume() {
    return 4*Math.PI/2*r3();
  }
} 

Public : utilisable par les tiers

Tout ce qui est public est utilisable par d’autre.

Contrat moral : si on utilise que la partie publique d’un objet (Java l’oblige), toute version future de la classe sera compatible avec ce qui est écrit.

Exemple :

• Version 1:

    public class Point {
      private double x;
      private double y;
      private double sqX() {
        return x*x;
      }
      private double sqY() {
        return y*y;
      }
      public double abscisse() {
        return x;
      }	
      public double ordonnee() {
        return y;
      }
      public double module() {
        return Math.sqrt(sqX()+sqY());
      }
      public double argument() {
        return Math.atan2(y,x);
      }
    }
  

• Version 2:

    public class Point {
      private double r;
      private double theta;
      public double abscisse() {
        return r*Math.cos(theta);
      }
      public double ordonnee() {
        return r*Math.sin(theta);
      }
      public double module() {
        return r;
      }
      public double argument() {
        return theta;
      }
    }
  

Rien de privé entre instances de la même classe

Privé ne veut pas dire réservé à soi mais réservé à sa classe.

Exemple :

class Vecteur {
  private double x;
  private double y;
  public Vecteur(double x,double y) {
    this.x=x;
    this.y=y;
  }
  public void ajoute(Vecteur v) {
    this.x+=v.x:
    this.y+=v.y;
  }
}

Quand il n’y a pas ambigüité avec les paramètres ou variables locales des méthodes ou constructeurs, on peut ommettre this. (déconseillé au début car cela fait des erreurs curieuses).

class Personne {
  private String prenom;
  private String nom;
  public Personne(String prenom, String nom) {
    this.prenom=prenom;
    this.nom=nom;
  }
  public void mariage(Personne personne) {
    nom=nom+"-"+personne.nom;
  }
}

Fonctions

Il est possible d’avoir des fonctions avec le mot-clef static.

Ce mot-clef signifie: « appelable sans référence à l’objet ».

• une fonction ne peut pas utiliser les champs de l’objet vu qu’elle n’a pas accès à une référence vers l’objet
• le compilateur java appelle cela le contexte statique : ce sont les endroits de la classe où l’on n’a pas accès au champs (essentiellement les corps des fonctions statiques).

Exemple de message d’erreur quand on accède à un champ depuis une fonction:

Error: non-static variable x cannot be referenced from a static context

On apelle donc souvent une fonction méthode statique mais le terme fonction est plus approprié.

Variables globales

Il est aussi possible d’avoir des variables globales: elle sont communes à tout le programme. Il suffit de mettre le mot-clef static devant le champ :

• On peut accéder à ce champ depuis les fonctions
• on peut y accéder depuis les méthodes aussi mais tous les objets partagent la même variable
• Si le champ est privé, seul les méthodes, fonctions et constructeurs de la classe peuvent y accéder

On appelle donc souvent une variable globale champ statique mais le terme variable globale est plus approprié. En cas d’ambigüité pas de this. réservé aux éléments non statiques mais à partir du nom de la classe.

Exemple :

class ObjetPayant() {
  private static int compteur;
  private double valeur;
  public ObjetPayant(double valeur) {
    compteur++;
    this.valeur = valeur;
  }
  public static void paye(double compteur) {
    ObjetPayant.compteur-=compteur;
  }
}

Bonnes pratiques

Les champs sont toujours privés

On ne rend publique que ce qui vraiment utilisé par d’autres objets

Une classe a une seule responsabilité

• Soit contenir des données:
  • Les présenter via des accesseurs, éventuellement de plusieurs manières
  • Proposer des modifications via des modificateurs
    • Ça n’est pas une obligation
    • Éventuellement de plusieurs manières
• Soit traiter des données :
  • Les fonctions annexes de traitement de données sont à mettre dans une autre classe
  • Ces classes ont souvent pas de champs

On essaye dans la mesure du possible de mettre les variables globales dans des classes sans champ (exception : les constantes, voir prochain cours)