Skip to main content

Approche objet : Bases

1 - L'objet :​

Définition :

Un objet est une structure de données contenant des variables et des méthodes qui lui sont propres.

Les variables stockent des informations, comme un nombre, une chaine de caractères, etc.

Les méthodes manipules ces informations. Par exemple, un objet "Carré" peut avoir une méthode "calculerAire" qui va utiliser l'information sur la longueur de ses cotés pour retourner son aire.

Les variables propres aux objets sont appelées propriétés.

Pour appeler les propriétés et les méthodes d'un objet, on utilise la syntaxe suivante :

objet.propriété objet.méthode

Pour créer un objet, on doit l'instancier à partir d'une classe, généralement de la façon suivante:

Classe objet = new Classe()

Instancier une classe, c'est créer un objet possédant les attributs et les méthodes décrites dans sa classe

2 - Les classes :​

Une classe sert à décrire la structure de données des objets qui seront créés (instanciés) à partir de cette classe.

Par exemple, supposons que l'on veuille créer un programme qui permet de calculer l'aire de'plusieurs rectangles en fonction de la longueur de leurs cotés. Dans ce cas, on peut créer un modèle de ce qui sera un rectangle : une structure ayant pour paramètre une longueur et une largeur. On peut également donner à cette structure une méthode qui renvoit son aire en fonction de sa longueur et sa largeur.

Un exemple de cette classe pourrait être le suivant :

public class Rectangle {
    double longueur; //une propriété stockant la longueur du rectangle sous la forme d'un réel
    double largeur; //une propriété stockant la largeur du rectangle sous la forme d'un réel
    
    double getAire(){ //méthode permettant de récupérer l'aire du rectangle sous la forme d'un réel.
        return longueur*largeur;
    }
}

Pour créer cet un objet Rectangle, il suffit maintenant d'écrire ceci:

Rectangle MonRectangle  = new Rectangle();

On peut valoriser ses propriétés. Par exemple, pour un rectangle de longueur 5 et de largueur, trois, on écrit ceci:

MonRectangle.longueur = 5;
MonRectangle.largeur = 3;

2.1 Les méthodes :​

Si l'on regarde l'exemple, on remarque la construction suivante :

type_de_retour nomMéthode (TypeParamètre paramètre){
    instructions
    retour du résultat
}

type_de_retour définit le type de ce qui sera renvoyé par la méthode.

TypeParamètre définit le type de l'argument passé à la méthode

paramètre correspond à l'argument passé à la méthode. Une méthode peut ne pas prendre de paramètre, ou en prendre plusieurs.

Un paramètre est une variable de la méthode que l'on passe lors de l'appel de la méthode, de cette façon:

Objet.nomMéthode(paramètre);

retour est l'instruction renvoyant la valeur. Il devient alors possible de conserver cette valeur dans une variable, ou de l'utiliser dans une autre méthode.

Par exemple, pour le rectangle:

Rectangle MonRectangle = new Rectangle();
MonRectangle.longueur = 5;
MonRectangle.largeur = 3;
System.out.println("Aire de mon rectangle : " + MonRectangle.getAire());

Ici, on utilise la valeur de retour de Rectangle.getAire() pour la passer en paramètre de la méthode System.out.println().

2.1.1 Les acesseurs​

Un acesseur est une méthode permettant de valoriser les propriétés d'un objet, ou de récupérer la valeur des propriétés d'un objet

Il y a deux types d'acesseur : les setters et les getters.

Un setter sert à valoriser une propriété d'un objet. Sa syntaxe générale est la suivante:

void setPropriété(TypeParamètre paramètre){
    this.attribut = paramètre;
}

Le mot clé this est une référence à l'objet courant. Cela permet de différencier les deux variables dans le cas où elles porteraient le même nom : this.attribut fait référence à un attribut de l'objet courant, tandis que paramètre fait référence à une variable locale de la méthode.

Exemple:

void setLongueur(double longueur){
    this.longueur = longueur;
}

Un getter permet de récupérer la valeur d'un attribut de l'objet.

Exemple:

double getLongueur(){
    return longueur
}

2.1.2 Les constructeurs​

Un constructeur est une méthode appelée lors de l'instanciation d'une classe. Il s'agit d'une méthode sans type, portant le nom de la classe.

Elle peut prendre des paramètres. Par exemple, on pourrait, lors de la construction du rectangle, on pourrait décider de valoriser sa longueur et sa largeur, comme ceci:

Rectangle(double longueur, double largeur){//Constructeur de la méthode. Il prend deux paramètres, longueur et largeur
    this.longueur = longueur;//on valorise l'attribut longueur à partir du paramètre longueur
    this.largeur = largeur;//on valorise l'attribut largeur à partir du paramètre largeur
}

2.1.3 La surcharge de méthodes​

Si l'on veut pouvoir une même méthode avec un nombre différents d'arguments, on peut créer deux méthodes avec un même nom et un nombre d'arguments différents Par exemple, si l'on veut pouvoir initialiser un rectangle sans préciser sa longueur ou sa largeur, on peut surcharger le constructeur de l'objet

Rectangle(double longueur, double largeur){
    this.longueur = longueur;
    this.largeur = largeur;
}

Rectangle(){ //On crée une deuxième méthode ne prenant pas d'argument
    this(5,3); //On passe des valeurs par défaut au constructeur à l'aide de l'opérateur this.
}

Lors de la surcharge du constructeur, on peut faire appel au constructeur avec un nombre d'arguments différents en utilisant this()

2.2 Les attributs et méthodes d'instance vs les attributs et méthodes d'objet​

Les attributs et méthodes sont par défaut des attributs et méthode d'instance.

Pour utiliser un attribut ou une méthode d'instance, il faut avoir instancier l'objet

On doit procéder de la façon suivante:

Classe objet = new Classe()
objet.méthode()

Pour utiliser un attribut ou une méthode d'instance, il n'est pas nécessaire d'avoir instancié l'objet.

On peut simplement utiliser la syntaxe suivante :

Classe.méthode()

Pour qu'un attribut ou une méthode soit de classe et non d'objet, il faut le précéder du mot static

Une méthode de classe ne peut accéder aux attributs d'instance, ni faire appel aux méthodes d'instance

Supposons par exemple que l'on souhaite simplement connaitre l'aire d'un rectangle et ne jamais réutiliser ce rectangle ensuite.

Il est alors inutile de créer une instance de classe rectangle, puisqu'on ne le réutilisera jamais par la suite.

Il peut donc être intéressant de créer une méthode de classe getAire() qui prendrait une longueur et une largeur en paramètre.

static double getAire(double longueur, double largeur){
    return longueur*largeur;
}

2.3 La visibilité des attributs et méthodes​

La visbilité d'une méthode ou d'un attribut correspond aux droits d'utilisation qu'ont les différentes parties du code quant à ces méthodes et attributs.

Il existe quatre niveaux de visibilité pour les méthodes et les attributs : -public -protected -package -private

Un attribut public peut être accédé n'importe où dans le code. On l'accorde aux méthodes qui vont servir à utiliser notre classe ou instance de classe.

Un attribut protected peut être accédé depuis le package, la classe ou ses les classes filles (voir la section héritage)

Un attribut package peut être accéder dans le même package que la classe, ainsi que dans la classe.

Un attribut private ne peut être accédé que dans sa classe ou ses classes filles.

Par convention, on met tous les paramètres en private, et on utilise des setters et des getters pour accéder aux variables ou les changer.

Récapitulatif​

public class Main {

    //on a rajouté les 
    static class Rectangle{
        private double longueur; //une propriété stockant la longueur du rectangle sous la forme d'un réel
        private double largeur; //une propriété stockant la largeur du rectangle sous la forme d'un réel

        private double getAire(){ //méthode permettant de récupérer l'aire du rectangle sous la forme d'un réel.
            return longueur*largeur;
        }

        public Rectangle(double longueur, double largeur){
            this.longueur = longueur;
            this.largeur = largeur;
        }

        Rectangle(){ //On crée une deuxième méthode ne prenant pas d'argument
            this(5,3); //On passe des valeurs par défaut au constructeur à l'aide de l'opérateur this.
        }
        public void setLongueur(double longueur){//acesseur permettant de définir la longueur du rectangle
            this.longueur = longueur;//Comme le paramètre de la méthode et la propriété de la classe portent le même nom, this permet de faire référence au paramètre de l'objet.
        }

        public void setLargeur(double largeur){//acesseur permettant de définir la largeur du rectangle
            this.largeur = largeur;
        }

        public double getLargeur() {//acesseur permettant de récupérer la largeur du rectangle
            return largeur;
        }

        public double getLongueur() {//acesseur permettant de récupérer la longueur du rectangle
            return longueur;
        }

        //On crée une méthode de classe permettant de récupérer l'aire d'un rectangle simplement en précisant en paramètre sa longueur et sa largeur.
        public static double getAire(double longueur, double largeur){
            return longueur*largeur;
        }
    }

    public static void main(String[] args) {
        //on crée une instance de la classe Rectangle, puis, en passant 10 et 7 en paramètre, on initialise sa longueur
        //et sa largeur.
        Rectangle monRectangle = new Rectangle(10,7);
        //on crée une instance de la classe Rectangle sans passer d'argument. Le rectangle prendra alors les valeurs par
        //défaut de 5 et 3 pour sa longueur et sa largeur
        Rectangle monDeuxiemeRectangle = new Rectangle();
        //On calcul l'aire du premier rectangle et on l'affiche dans la console
        System.out.println(monRectangle.getAire());
        //On utilise la méthode de classe getAire pour calculer l'aire d'un rectangle de 5 par 5
        System.out.println(Rectangle.getAire(5,5));
    }
}