Php object

De The Linux Craftsman
Aller à : navigation, rechercher

Introduction

Concrètement, un objet est une structure de données valuées et cachées qui répond à un ensemble de messages. Cette structure de données définit son état tandis que l'ensemble des messages qu'il comprend décrit son comportement :

  • Les données — ou champs — qui décrivent sa structure interne sont appelées ses attributs ;
  • L'ensemble des messages forme ce que l'on appelle l'interface de l'objet ; c'est seulement au travers de celle-ci que les objets interagissent entre eux. La réponse à la réception d'un message par un objet est appelée une méthode (méthode de mise en œuvre du message) ; elle décrit quelle réponse doit être donnée au message.

Certains attributs et/ou méthodes (ou plus exactement leur représentation informatique) sont cachés : c'est le principe d'encapsulation. Ainsi, le programme peut modifier la structure interne des objets ou leurs méthodes associées sans avoir d'impact sur les utilisateurs de l'objet.

Wikipedia

Implémentation

Définition

La définition d'un objet en PHP se fait grâce au mot clé class. Nous allons placer le code suivant dans un fichier nommé Rectangle.class.php (notez le .class.php).

class Rectangle{
    ...
}

Attributs et visibilité

L'objet précédent est vide, nous allons lui ajouter quelques attributs:

class Rectangle {
    
    public $x, $y, $largeur, $hauteur;

    ...
}

Notez le public qui précède la liste des attributs, il sert à définir la visibilité.

La visibilité d'un attribut ou d'une méthode indique à partir d'où on peut avoir accès à telle méthode ou tel attribut.

Il y a 3 types de visibilité : public, private (privé) et protected (protégé)

  • Accès public : c’est le plus simple. Si un attribut ou une méthode est public, alors on pourra avoir accès à cet attribut ou cette méthode depuis n'importe où, autant depuis l'intérieur de l'objet (dans les méthodes qu'on a créées, on aura accès aux éléments publics), mais aussi depuis l'extérieur.
  • Accès privé : il impose quelques restrictions. On aura accès aux attributs et méthodes que depuis l'intérieur de la classe, c'est-à-dire que seul le code écrit à l'intérieur de la classe fonctionnera. Les héritiers n’ont pas accès à un élément privé.
  • Accès protégé : C’est comme l’accès privé sauf qu’un tel attribut (ou méthode) est accessible aussi par les classes qui héritent de la classe mère.

Ceci est la base de l'encapsulation.

Constructeur

Le constructeur est la méthode qui permet de créer l'objet lorsque l'on utilise le mot clé new (que nous verrons plus tard).

public function Rectangle($x, $y, $largeur, $hauteur){
    $this->x = $x;
    $this->y = $y;
    $this->largeur = $largeur;
    $this->hauteur = $hauteur;
}

A partir de maintenant on peut instancier notre objet rectangle même si il ne sait pas faire grand chose pour le moment.

Ajout d'une méthode

Nous allons doter notre objet Rectangle de la capacité de se dessiner. Pour cela nous allons ajouter une fonction draw qui renverra la chaîne de caractères représentant le rectangle.

class Rectangle {
    ...

    public function draw() {
        $result = "";
        for($i = 1; $i < $this->y; $i ++) {
            $result += ".<br/>";
        }
        for($i = 0; $i < $this->hauteur; $i ++) {
            for($j = 1; $j < $this->x; $j ++) {
                $result += ".";
            }
            for($j = 0; $j < $this->largeur; $j ++) {
                $result += "*";
            }
            $result += "<br/>";
        }
        return $result;
    }
}

On peut remarquer que:

  • l'accès aux attributs de l'objet se fait grâce à $this->;
  • $this fait référence à l'objet instancié et peut être utilisé uniquement à l'intérieur de la classe;
  • il n'y a pas besoin de déclarer une variable avant de pouvoir l'utiliser (comme en C par exemple).

Appel de l'objet

Créons une page PHP nommé main.php qui appellera notre objet et affichera le rendu

<?php

include __DIR__.'/Rectangle.class.php';

$rectangle = new Rectangle(5, 3, 19, 9);
echo $rectangle->draw();

?>

On peut remarquer que:

  • l'instanciation de l'objet se fait grâce au mot clé new;
  • l'accès aux fonctions et attributs de l'objet se fait grâce à ->;


Et voici le résultat :

# php -f main.php
.
.
....*******************
....*******************
....*******************
....*******************
....*******************
....*******************
....*******************
....*******************
....*******************

Application

La classe Point

Pour programmer une classe Rectangle, on commence par définir la classe Point, suivant le squelette ci-dessous, où x et y représentent les coordonnées dans le plan :

class Point{
   public a, b;
   public Point(a, b){...}
   public Point(){...};
   public distance(Point p){...}
   public equals(Object o){...}
   public toString(...){}
}

Programmez les constructeurs et les méthodes en accord avec la documentation suivante :

  • Point(): construit le point origine des coordonnées (0,0);
  • Point(a, b): construit le point de coordonnées (a, b);
  • distance(Point p): retourne la distance euclidienne entre le point appelant et p
  • equals(Object o): renvoie true si le point appelant et le point paramètres sont les mêmes (ont les mêmes coordonnées);
  • toString(): renvoie une représentation sous forme de chaîne de caractères du point appelant par exemple, (2.0,3.0) pour le point de coordonnées (2,3);

Rappel pour calculer la distance euclidienne entre deux points A et B : AB = \sqrt{(x_B-x_A)^2 + (y_B-y_A)^2}

Programmez une méthode main pour tester cette classe.

La classe Rectangle

On considère maintenant le squelette suivant pour la classe Rectangle, un rectangle étant défini par deux points aux extrémités d’une diagonale :

class Rectangle{
   public Point ext1;
   public Point ext2;
   public Rectangle(){...}
   public Rectangle(Point a, Point b){...}
   public Rectangle(Point a, width, height){}
   public longueur(){}
   public hauteur(){}
   public perimetre(){}
   public surface(){}
   public contient(Point p){}
   public symetrique(){}
}

Programmez les constructeurs et les méthodes en accord avec la documentation suivante :

  • Rectangle(Point a, Point b): construit le rectangle dont les points a et b sont les extrémités d’une diagonale;
  • Rectangle(): construit le rectangle réduit à un point (l’origine des coordonnées);
  • Rectangle(Point a, b, c): construit un rectangle dont a est le coin supérieur gauche, width la longueur et height la hauteur;
  • longueur(): retourne la longueur du rectangle appelant;
  • hauteur(): retourne la hauteur du rectangle appelant;
  • perimetre(): retourne le périmètre du rectangle appelant;
  • surface(): retourne la surface du rectangle appelant;
  • contient(Point p): renvoie true si le point paramètre p est à l’intérieur du rectangle appelant;
  • Rectangle symetrique(): renvoie le rectangle obtenu à partir du rectangle appelant par symétrie par rapport à la première diagonale.


Programmez une méthode main pour tester cette classe