Programmation orientée objet PHP

Dans la programmation orientée objet (en anglais : Object-Programmation orientée objet, abrégé : OOP) où un objet est un ensemble composé de descriptions d'informations et de traitements des informations, qui est une abstraction du monde réel.

Dans le monde réel, les choses auxquelles nous sommes confrontés sont des objets, comme les ordinateurs, les téléviseurs, les vélos, etc.

Les trois principales caractéristiques de l'objet :

• Comportement de l'objet : Les opérations qui peuvent être appliquées à l'objet, allumer, éteindre sont des comportements.

• Forme de l'objet : Comment l'objet réagit aux méthodes appliquées, couleur, taille, forme.

• Représentation de l'objet : La représentation de l'objet est équivalente à une carte d'identité, la distinction spécifique réside dans les différences dans les comportements et les états identiques.

Par exemple, Animal (animal) est une classe abstraite, nous pouvons nous concentrer sur un chien et un mouton, et un chien et un mouton sont des objets concrets, ils ont des attributs de couleur, peuvent écrire, peuvent courir, etc.

Contenu orienté objet

• Classe − Définit les caractéristiques abstraites d'une chose. La définition de la classe contient la forme des données et les opérations sur les données.

• Objet Est une instance de la classe.

• Variable membre − Défini à l'intérieur de la classe, c'est une variable whose value is invisible from the outside, but can be accessed through member functions. After the class is instantiated as an object, this variable can be called the attribute of the object.

• Fonction membre − Défini à l'intérieur de la classe,可用于访问对象的数据。

• inheritance − L'héritage est un mécanisme par lequel une sous-classe partage automatiquement les structures de données et les méthodes de la classe mère, c'est une relation entre les classes. Lors de la définition et de l'implémentation d'une classe, on peut s'appuyer sur une classe existante, utiliser le contenu défini par cette classe existante comme contenu propre, et ajouter un certain nombre de nouveaux contenus.

• Classe mère − Une classe qui est héritée par une autre classe peut être appelée classe mère, ou classe de base, ou classe parente.

• Sous-classe − Une classe qui hérite d'une autre classe est appelée sous-classe, ou classe dérivée.

• Polymorphisme − La polymorphisme est le fait que les mêmes fonctions ou méthodes peuvent agir sur plusieurs types d'objets et obtenir des résultats différents. Des objets différents peuvent produire des résultats différents en recevant le même message, ce phénomène s'appelle polymorphisme.

• Surcharge − En termes simples, c'est la situation où les fonctions ou les méthodes ont le même nom, mais les listes de paramètres sont différentes. Ces fonctions ou méthodes avec des noms identiques mais des paramètres différents s'appellent fonction ou méthode surchargée.

• Abstraction − L'abstraction consiste à abstraire les objets qui ont des structures de données (attributs) et des comportements (opérations) cohérents en classes. Une classe est ainsi une abstraction qui reflète les propriétés importantes liées à l'application, en négligeant d'autres contenus non pertinents. Toute division de classe est subjective, mais doit être liée à l'application spécifique.

• Encapsulation − L'encapsulation consiste à lier les attributs et les comportements d'un objet existant dans le monde réel ensemble et à les placer dans une unité logique.

• Constructor − Principalement utilisé pour initialiser les objets lors de leur création, c'est-à-dire attribuer des valeurs initiales aux variables membres de l'objet, toujours utilisé avec l'opérateur new dans les instructions de création d'objets.

• Destructeur − Fonction destructrice (destructor) : à l'inverse de la fonction constructrice, la fonction destructrice est automatiquement exécutée par le système lorsque l'objet termine sa vie (par exemple, lorsque la fonction dans laquelle l'objet est situé est appelée). La fonction destructrice est souvent utilisée pour effectuer des "nettoies" (par exemple, si un espace mémoire est alloué avec new lors de la création de l'objet, il doit être libéré avec delete avant de quitter).

Dans l'image suivante, nous avons créé trois objets via la classe Car : Mercedes, Bmw et Audi.

$mercedes = new Car();
$bmw = new Car();
$audi = new Car();

Définition de la classe PHP

La syntaxe habituelle de la définition de la classe en PHP est la suivante :

<?php
class phpClass {
　　var $var1;
　　var $var2　= 'string constante';
　　
　　function myfunc ($arg1, $arg2) {
　　　　　[..]
　　}
　　[..]
}
?>

L'analyse suit :

• L'utilisation de la classe class Le mot-clé suivi du nom de la classe pour définir.

• Dans les accolades ({}) après le nom de la classe, vous pouvez définir des variables et des méthodes.

• Les variables de la classe utilisent var Pour déclarer, les variables peuvent également être initialisées.

• La définition de la fonction est similaire à la définition de la fonction en PHP, mais la fonction ne peut être accessible que par la classe et les objets instanciés de cette classe.

示例

<?php
class Site {
　　/*　Variable membre　*/
　　var $url;
　　var $title;
　　
　　/*　Fonction membre　*/
　　function setUrl($par){
　　　　　$this->url = $par;
　　}
　　
　　function getUrl(){
　　　　　echo $this->url . PHP_EOL;
　　}
　　
　　function setTitle($par){
　　　　　$this->title = $par;
　　}
　　
　　function getTitle() {
　　　　　echo $this->title . PHP_EOL;
　　}
}
?>

Variable $this représente l'objet lui-même.

PHP_EOL Pour le retour chariot.

Création d'objet en PHP

Après avoir créé la classe, nous pouvons utiliser new L'opérateur pour instancier l'objet de la classe :

$w3codebox = new Site;
$taobao = new Site;
$google = new Site;

Les codes ci-dessus créent trois objets, les trois objets sont indépendants les uns des autres, regardons maintenant comment accéder aux méthodes membres et aux variables membres.

Appel de la méthode membre

Après avoir instancié l'objet, nous pouvons utiliser cet objet pour appeler les méthodes membres, les méthodes membres ne peuvent manipuler que les variables membres de cet objet :

//　Appel de la fonction membre, configuration du titre et de l'URL
$w3codebox->setTitle( "Réseau de tutoriels de base" );
$taobao->setTitle('淘宝');
$google->setTitle( "Google Recherche" );
$w3codebox->setUrl( 'www.w3>setUrl( 'codebox.com' );
$taobao->setUrl('www.taobao.com');
$google->setUrl( 'www.google.com' );
//　Appel de la fonction membre pour obtenir le titre et l'URL
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();

Le code complet est le suivant :

<?php
class Site {
　　/*　Variable membre　*/
　　var $url;
　　var $title;
　　
　　/*　Fonction membre　*/
　　function setUrl($par){
　　　　　$this->url = $par;
　　}
　　
　　function getUrl(){
　　　　　echo $this->url . PHP_EOL;
　　}
　　
　　function setTitle($par){
　　　　　$this->title = $par;
　　}
　　
　　function getTitle() {
　　　　　echo $this->title . PHP_EOL;
　　}
}
$w3codebox = new Site;
$taobao = new Site;
$google = new Site;
//　Appel de la fonction membre, configuration du titre et de l'URL
$w3codebox->setTitle( "Réseau de tutoriels de base" );
$taobao->setTitle( "Tmall商城" );
$google->setTitle( "Google Recherche" );
$w3codebox->setUrl( 'www.w3>setUrl( 'codebox.com' );
$taobao->setUrl( 'www.tmall.com' );
$google->setUrl( 'www.google.com' );
//　Appel de la fonction membre pour obtenir le titre et l'URL
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();
?>

En exécutant le code ci-dessus, le résultat de la sortie est :

Réseau de tutoriels de base
Tmall商城
Google Recherche
fr.oldtoolbag.com
www.tmall.com
www.google.com

Constructeur PHP

Le constructeur est une méthode spéciale. Il est principalement utilisé pour initialiser l'objet lors de sa création, c'est-à-dire attribuer des valeurs initiales aux variables membres de l'objet, en utilisant l'opérateur new lors de l'instruction de création d'objet.

PHP 5 Permet aux développeurs de définir une méthode dans une classe en tant que constructeur, suivant la syntaxe suivante :

void __construct ([ mixed $args [, $... ]]] )

Dans l'exemple précédent, nous pouvons utiliser la méthode de construction pour initialiser les variables $url et $title :

function __construct( $par1, $par2　) {
　　　$this->url = $par1;
　　　$this->title = $par2;
}

Maintenant, nous n'avons plus besoin d'appeler les méthodes setTitle et setUrl :

$w3codebox = new Site('fr.oldtoolbag.com', 'Réseau de tutoriels de base');
$tmall = new Site('www.tmall.com', 'Tmall商城');
$google = new Site('www.google.com', 'Google Recherche');
//　Appel de la fonction membre pour obtenir le titre et l'URL
$w3codebox->getTitle();
$tmall->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$tmall->getUrl();
$google->getUrl();

Destructeur

Le destructeur (détructeur) est l'opposé du constructeur. Il est automatiquement exécuté par le système lorsque l'objet termine sa vie (par exemple, lorsque la fonction dans laquelle l'objet se trouve a été appelée).

PHP 5 L'introduction du concept de destructeur, similaire à celui des autres langages orientés objet, suit la syntaxe suivante :

void __destruct ( void )

示例

<?php
class MyDestructableClass {
　　　function __construct() {
　　　　　　　print "构造函数\n";
　　　　　　　$this->name = "MyDestructableClass";
　　　}
　　　function __destruct() {
　　　　　　　print "Destroy " . $this->name . "\n";
　　　}
}
$obj = new MyDestructableClass();
?>

En exécutant le code ci-dessus, le résultat de la sortie est :

Constructor
Destroy MyDestructableClass

inheritance

PHP uses the keyword extends To inherit a class, PHP does not support multiple inheritance, and the format is as follows:

class Child extends Parent {
　　　//　Code section
}

示例

In the example, the Child_Site class inherits from the Site class and extends the functionality:

<?php　
//　Subclass extends site category
class Child_Site extends Site {
　　　var $category;
　　　　function setCate($par) {
　　　　　　　　$this->category = $par;
　　　　}
　　
　　　　function getCate() {
　　　　　　　　echo $this->category . PHP_EOL;
　　　　}
}

Method rewriting

If the methods inherited from the parent class do not meet the needs of the subclass, they can be rewritten, which is called method overriding (override) or method rewriting.

In the example, the getUrl and getTitle methods are overridden:

function getUrl() {
　　　echo $this->url . PHP_EOL;
　　　return $this->url;
}
　　　
function getTitle() {
　　　echo $this->title . PHP_EOL;
　　　return $this->title;
}

Access control

PHP implements access control for attributes or methods by adding the keywords public (public), protected (protected), or private (private) in front of them.

• public (public):Public class members can be accessed anywhere.

• protected (protected):Protected class members can be accessed by themselves, their subclasses, and their parent classes.

• private (private):Private class members can only be accessed by the class in which they are defined.

Attribute access control

Class properties must be defined as public, protected, or private. If defined with var, it is considered public.

<?php
/**
　*　Définir MyClass
　*/
class MyClass
{
　　　　public $public = 'Public';
　　　　protected $protected = 'Protected';
　　　　private $private = 'Private';
　　　　function printHello()
　　　　{
　　　　　　　　echo $this->public;
　　　　　　　　echo $this->protected;
　　　　　　　　echo $this->private;
　　　　}
}
$obj = new MyClass();
echo $obj->public;　//　Cette ligne peut être exécutée normalement
echo $obj->protected;　//　Cette ligne会产生一个致命错误
echo $obj->private;　//　This line will also produce a fatal error
$obj->printHello();　//　Output Public, Protected and Private
/**
　*Définir MyClass2
　*/
class MyClass2　extends MyClass
{
　　　　//　Il est possible de redéfinir public et protected, mais pas private
　　　　protected $protected = 'Protected'2';
　　　　function printHello()
　　　　{
　　　　　　　　echo $this->public;
　　　　　　　　echo $this->protected;
　　　　　　　　echo $this->private;
　　　　}
}
$obj2　= new MyClass2();
echo $obj2->public;　//　Cette ligne peut être exécutée normalement
echo $obj2->private;　//　Non défini private
echo $obj2->protected;　//　Cette ligne会产生一个致命错误
$obj2->printHello();　//　Sortie Public, Protected2　et Undefined
?>

Contrôle d'accès des méthodes

Les méthodes d'une classe peuvent être définies comme publiques, privées ou protégées. Si ces mots-clés ne sont pas définis, la méthode est par défaut publique.

<?php
/**
　*　Définir MyClass
　*/
class MyClass
{
　　　　//　Déclarer un constructeur public
　　　　public function __construct() { }
　　　　//　Déclarer une méthode publique
　　　　public function MyPublic() { }
　　　　//　Déclarer une méthode protégée
　　　　protected function MyProtected() { }
　　　　//　Déclarer une méthode privée
　　　　private function MyPrivate() { }
　　　　//　Cette méthode est publique
　　　　function Foo()
　　　　{
　　　　　　　　$this->MyPublic();
　　　　　　　　$this->MyProtected();
　　　　　　　　$this->MyPrivate();
　　　　}
}
$myclass = new MyClass;
$myclass->MyPublic();　//　Cette ligne peut être exécutée normalement
$myclass->MyProtected();　//　Cette ligne会产生一个致命错误
$myclass->MyPrivate();　//　Cette ligne会产生一个致命错误
$myclass->Foo();　//　Les membres publics, protégés et privés peuvent tous être exécutés
/**
　*　Définir MyClass2
　*/
class MyClass2　extends MyClass
{
　　　　//　Cette méthode est publique
　　　　function Foo2()
　　　　{
　　　　　　　　$this->MyPublic();
　　　　　　　　$this->MyProtected();
　　　　　　　　$this->MyPrivate();　//　Cette ligne会产生一个致命错误
　　　　}
}
$myclass2　= new MyClass2;
$myclass2->MyPublic();　//　Cette ligne peut être exécutée normalement
$myclass2->Foo2();　//　Les membres publics et protégés peuvent être exécutés, mais pas les membres privés
class Bar　
{
　　　　public function test() {
　　　　　　　　$this->testPrivate();
　　　　　　　　$this->testPublic();
　　　　}
　　　　public function testPublic() {
　　　　　　　　echo "Bar::testPublic\n";
　　　　}
　　　　
　　　　private function testPrivate() {
　　　　　　　　echo "Bar::testPrivate\n";
　　　　}
}
class Foo extends Bar　
{
　　　　public function testPublic() {
　　　　　　　　echo "Foo::testPublic\n";
　　　　}
　　　　
　　　　private function testPrivate() {
　　　　　　　　echo "Foo::testPrivate\n";
　　　　}
}
$myFoo = new foo();
$myFoo->test();　//　Bar::testPrivate　
　　　　　　　　　　　　　　　　//　Foo::testPublic
?>

Interface

En utilisant l'interface (interface), on peut spécifier quelles méthodes une classe doit implémenter, sans définir le contenu spécifique de ces méthodes.

L'interface est définie par interface Défini par un mot-clé, comme une classe standard, mais toutes les méthodes définies sont vides.

Toutes les méthodes définies dans l'interface doivent être publiques, c'est une caractéristique de l'interface.

Pour implémenter une interface, utiliser implements L'implémentation de l'interface. La classe doit implémenter toutes les méthodes définies dans l'interface, sinon une erreur fatale sera signalée. Une classe peut implémenter plusieurs interfaces, séparées par des virgules.

<?php
//　Déclarer une interface 'iTemplate'
interface iTemplate
{
　　　　public function setVariable($name, $var);
　　　　public function getHtml($template);
}
//　Mettre en œuvre l'interface
class Template implements iTemplate
{
　　　　private $vars = array();
　　
　　　　public function setVariable($name, $var)
　　　　{
　　　　　　　　$this-vars[$name] = $var;
　　　　}
　　
　　　　public function getHtml($template)
　　　　{
　　　　　　　　foreach($this-foreach($this
　　　　　　　　　　　　$template = str_replace('{'. $name .'}', $value, $template);
　　　　　　　　}
　
　　　　　　　　return $template;
　　　　}
}

Constante

On peut définir une valeur qui reste constante dans une classe comme une constante. Lors de la définition et de l'utilisation des constantes, il n'est pas nécessaire d'utiliser le symbole $.

La valeur de la constante doit être une valeur fixe, elle ne peut pas être une variable, une propriété de classe, le résultat d'une opération mathématique ou un appel de fonction.

Depuis PHP 5.3.0 à partir de, on peut utiliser une variable pour appeler dynamiquement la classe. Mais la valeur de cette variable ne peut pas être un mot-clé (comme self, parent ou static).

示例

<?php
class MyClass
{
　　　　const constant = '常量值';
　　　　function showConstant() {
　　　　　　　　echo self::constant . PHP_EOL;
　　　　}
}
echo MyClass::constant . PHP_EOL;
$classname = "MyClass";
echo $classname::constant . PHP_EOL;　//　de　5.3.0 débute
$class = new MyClass();
$class->showConstant();
echo $class::constant . PHP_EOL;　//　de PHP　5.3.0 débute
?>

Classe abstraite

Toute classe qui contient au moins une méthode déclarée comme abstraite doit être déclarée comme abstraite.

Les classes déclarées comme abstraites ne peuvent pas être instanciées.

Les méthodes déclarées comme abstraites ne définissent que la manière de les appeler (paramètres), mais ne définissent pas leur implémentation fonctionnelle.

Lorsqu'une sous-classe hérite d'une classe abstraite, elle doit définir toutes les méthodes abstraites de la classe parente ; en plus, les contraintes d'accès de ces méthodes doivent être les mêmes (ou plus larges) que dans la classe parente. Par exemple, si une méthode abstraite est déclarée comme protégée, alors la méthode implémentée dans la sous-classe doit être déclarée comme protégée ou publique, et ne peut pas être définie comme privée.

<?php
abstract class AbstractClass
{
　//　Il est obligatoire pour les sous-classes de définir ces méthodes
　　　　abstract protected function getValue();
　　　　abstract protected function prefixValue($prefix);
　　　　//　méthode ordinaire (non méthode abstraite)
　　　　public function printOut() {
　　　　　　　　print $this->getValue() . PHP_EOL;
　　　　}
}
class ConcreteClass1　extends AbstractClass
{
　　　　protected function getValue() {
　　　　　　　　return "ConcreteClass1";
　　　　}
　　　　public function prefixValue($prefix) {
　　　　　　　　return "{$prefix}ConcreteClass1";
　　　　}
}
class ConcreteClass2　extends AbstractClass
{
　　　　public function getValue() {
　　　　　　　　return "ConcreteClass2";
　　　　}
　　　　public function prefixValue($prefix) {
　　　　　　　　return "{$prefix}ConcreteClass2";
　　　　}
}
$class1　= new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;
$class2　= new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

En exécutant le code ci-dessus, le résultat de la sortie est :

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

De plus, une méthode de sous-classe peut inclure des paramètres optionnels qui n'existent pas dans la méthode abstraite de la classe parente.

Par exemple, une sous-classe peut définir un paramètre optionnel, même si la déclaration de la méthode abstraite de la classe parente ne le contient pas, et cela peut fonctionner normalement.

<?php
abstract class AbstractClass
{
　　　　//　Notre méthode abstraite nécessite uniquement les paramètres nécessaires.
　　　　abstract protected function prefixName($name);
}
class ConcreteClass extends AbstractClass
{
　　　　//　Notre sous-classe peut définir des paramètres optionnels qui n'existent pas dans la signature du parent.
　　　　public function prefixName($name, $separator = ".") {
　　　　　　　　if ($name == "Pacman") {
　　　　　　　　　　　　$prefix = "Mr";
　　　　　　　　} elseif ($name == "Pacwoman") {
　　　　　　　　　　　　$prefix = "Mrs";
　　　　　　　　} else {
　　　　　　　　　　　　$prefix = "";
　　　　　　　　}
　　　　　　　　return "{$prefix}{$separator} {$name}";
　　　　}
}
$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>

Le résultat de la sortie est :

Mr. Pacman
Mrs. Pacwoman

Mot-clé static

Déclarer une propriété ou une méthode de classe comme static (statique) permet d'accéder directement sans instancier la classe.

Les attributs statiques ne peuvent pas être accédés par un objet déjà实例ié de la classe (mais les méthodes statiques peuvent).

Comme les méthodes statiques peuvent être appelées sans objet, le pseudo-variables $this n'est pas disponible dans les méthodes statiques.

Les attributs statiques ne peuvent pas être accédés par -> opérateur pour accéder.

Depuis PHP 5.3.0 à partir de, on peut utiliser une variable pour appeler dynamiquement une classe. Mais la valeur de cette variable ne peut pas être les mots-clés self, parent ou static.

<?php
class Foo {
　　public static $my_static = 'foo';
　　
　　public function staticValue() {
　　　　　return self::$my_static;
　　}
}
print Foo::$my_static . PHP_EOL;
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
?>

Exécuter le programme ci-dessus, le résultat de la sortie est :

foo
foo

Mot-clé final

PHP 5 Un nouveau mot-clé final a été ajouté. Si une méthode de la classe parente est déclarée comme final, la classe fille ne peut pas surcharger cette méthode. Si une classe est déclarée comme final, elle ne peut pas être héritée.

L'exécution du code suivant entraînera une erreur :

<?php
class BaseClass {
　　　public function test() {
　　　　　　　echo "BaseClass::test() called" . PHP_EOL;
　　　}
　　　
　　　final public function moreTesting() {
　　　　　　　echo "BaseClass::moreTesting() called" . PHP_EOL;
　　　}
}
class ChildClass extends BaseClass {
　　　public function moreTesting() {
　　　　　　　echo "ChildClass::moreTesting() called" . PHP_EOL;
　　　}
}
//　Message d'erreur fatal: Cannot override final method BaseClass::moreTesting()
?>

Appel du constructeur de la classe parente

PHP ne called automatiquement le constructeur de la classe parente dans le constructeur de la sous-classe. Pour appeler le constructeur de la classe parente, il faut appeler explicitement dans le constructeur de la sous-classe parent::__construct(); .

<?php
class BaseClass {
　　　function __construct() {
　　　　　　　print "BaseClass classe avec le constructeur" . PHP_EOL;
　　　}
}
class SubClass extends BaseClass {
　　　function __construct() {
　　　　　　　parent::__construct();　　//　Le constructeur de la sous-classe ne peut pas appeler automatiquement le constructeur de la classe parente
　　　　　　　print "SubClass classe avec le constructeur" . PHP_EOL;
　　　}
}
class OtherSubClass extends BaseClass {
　　　　//　Hérite du constructeur de BaseClass
}
//　Appel du constructeur de BaseClass
$obj = new BaseClass();
//　Appel des constructeurs de BaseClass et SubClass
$obj = new SubClass();
//　Appel du constructeur de BaseClass
$obj = new OtherSubClass();
?>

Exécuter le programme ci-dessus, le résultat de la sortie est :

BaseClass classe avec le constructeur
BaseClass classe avec le constructeur
SubClass classe avec le constructeur
BaseClass classe avec le constructeur