Définition des classes

En PHP, une classe se définit à l'aide du mot-clé class, suivi du nom de la classe. Les propriétés et méthodes sont déclarées à l'intérieur de la paire d'accolades {}.

<?php
class Website {
  // Propriétés
  public string $domain;
  public string $name;

  // Méthodes
  public function setDomain(string $value): void {
    $this->domain = $value;
  }

  public function getDomain(): string {
    return $this->domain;
  }

  public function setName(string $value): void {
    $this->name = $value;
  }

  public function getName(): string {
    return $this->name;
  }
}
?>

Instanciation d'objets

Une fois la classe définie, on peut créer des instances à l'aide de l'opérateur new :

$amazon = new Website();
$bing = new Website();

Constructeurs et destructeurs

Constructeur

Le constructeur est une méthode spéciale __construct() exécutée automatiquement à l'instanciation :

public function __construct(string $domain, string $name) {
  $this->domain = $domain;
  $this->name = $name;
}

Utilisation :

$amazon = new Website('www.amazon.com', 'Amazon');

Destructeur

Le destructeur __destruct() est appelé automatiquement lorsqu'un objet n'est plus utilisé :

public function __destruct() {
  echo "Nettoyage de l'objet " . $this->name . "\n";
}

Héritage

PHP utilise le mot-clé extends pour implémenter l'héritage. Contrairement à d'autres langages, PHP ne supprote pas l'héritage multiple.

class ChildClass extends ParentClass {
  // Implémentation
}

Surcharge de méthodes

Une classe enfant peut redéfinir les méthodes héritées :

class Child extends Parent {
  public function greet(): void {
    parent::greet(); // Appel à la méthode parente
    echo " Et bienvenue depuis l'enfant !";
  }
}

Contrôle d'accès

PHP propose trois niveaux de visibilité :

• public : accessible depuis n'importe où
• protected : accessible dans la classe et ses anfants
• private : acessible uniquement dans la classe de définition

Interfaces et classes abstraites

Interfaces

Les interfaces définissent des contrats à respecter :

interface Template {
  public function render(string $content): string;
}

class BasicTemplate implements Template {
  public function render(string $content): string {
    return "<div>{$content}</div>";
  }
}

Classes abstraites

Une classe abstraite ne peut pas être instanciée directement :

abstract class Base {
  abstract public function process(): string;
}

class Concrete extends Base {
  public function process(): string {
    return "Traitement effectué";
  }
}

Mots-clés spéciaux

• parent : pour accéder aux méthodes parentes
• self : pour accéder aux membres statiques
• this : pour référencer l'instance courante

Constantes

Les constantes se définissent avec const :

class Config {
  const MAX_RETRY = 5;
}

Membres statiques

Les membres statiques s'accèdent avec l'opérateur :: :

class Counter {
  public static int $count = 0;
}

echo Counter::$count;

Classe et méthode finale

Le mot-clé final empêche la surcharge de méthodes ou l'héritage :

final class Security {
  final public function encrypt(string $data): string {
    return md5($data); // Méthode non modifiable
  }
}