Les objets sont des structures de données contenant des variables (appelées attributs) et des fonctions (appelées méthodes).
Les classes sont la définition, le modèle, le "moule" qui permet de fabriquer des objets.
Mot clé : class
<?php
class Personne
{
}
?>
Portée (visibilité) :
<?php
class Personne
{
private $_prenom;
private $_nom;
private $_age;
// Constructeur
public function __construct($prenom, $nom)
{
$this->_prenom = $prenom;
$this->_nom = $nom;
}
public function sePresenter()
{
echo 'Bonjour ! Je m\'appelle '.$this->_prenom.' '.$this->_nom;
}
}
?>
<?php
class Personne
{
...
}
$tom = new Personne('Tom', 'Doyen');
$tom->sePresenter();
?>
echo $tom;)Définit un cas particulier d'une classe. Par exemple, un Etudiant est une Personne, avec des choses en plus.
<?php
class Personne
{
...
}
class Etudiant extends Personne // Un Etudiant est un cas particulier de Personne
{
private $_num_etudiant; // qui a en plus un numéro étudiant
public function __construct($prenom, $nom, $num_etudiant)
{
parent::__construct($prenom, $nom); // appel du constructeur de la classe Personne
$this->_num_etudiant = $num_etudiant; // puis initialisation des attributs spécifiques
}
public function sePresenter() // redéfinit la méthode de la classe Personne
{
parent::sePresenter(); // appel de la méthode de la classe Personne (sans cette ligne la redéfinition est totale)
echo 'Et mon numéro étudiant est '.$this->_num_etudiant;
}
}
?>
Contraintes de typage des paramètres d'une fonction
<?php
function faireParler(Personne $p)
{
// on sait que $p est une Personne, donc cette ligne va marcher
$p->sePresenter();
// $p est peut être une classe fille, un Etudiant par exemple !
// ce n'est pas gênant, un Etudiant EST une Personne et sait donc se présenter.
}
$tom = new Etudiant('Tom', 'Doyen', 'p12345678');
faireParler($tom); // À votre avis, est-ce que c'est sePresenter de Personne ou d'Etudiant qui sera appelé ?
?>
<?php
class a
{
public static function parler()
{
echo 'Hello World';
}
}
a::parler();
?>
<?php
class a
{
private static $compteur = 0;
private $mon_numero;
public function __construct()
{
self::$compteur++;
$this->mon_numero = self::$compteur;
}
public static function parler()
{
echo 'Je suis le '.$this->mon_numero.'eme (sur '.self::$compteur.' au total)';
}
}
?>
<?php
abstract class Vehicule
{
private $numeroDeSerie;
public function getNumeroDeSerie() { return $this->numeroDeSerie; }
public abstract function seDeplacer();
}
class Voiture extends Vehicule
{
private ...
public function seDeplacer()
{
$this->pedaleAccelerateur->appuyer();
}
}
class Moto extends Vehicule
{
private ...
public function seDeplacer()
{
$this->poignee->tourner();
}
}
?>
À quoi ça sert ?
<?php
interface SaitParler
{
public function parler();
}
class Personne implements SaitParler
{
public function parler()
{
echo 'Hello World';
}
}
class Robot implements SaitParler
{
public function parler()
{
echo '10100110100';
}
}
?>
À quoi ça sert ?
Déclare un comportement (saitParler) qui est garanti être appelable par tous ceux qui implémentent SaitParler
implements Int1, Int2, Int3), alors qu'on ne peut étendre que d'une classe<?php
function faireParler(SaitParler $sp)
{
echo 'Tu vas parler, ordure ?';
$sp->parler();
}
?>
foreach sur nos propres classes)