En programmation orientée objet (anglais : Programmation orientée objet, abréviation : OOP), un objet est un tout composé d'informations et d'une description de la manière de traiter les informations, et est une abstraction du monde réel.
Dans le monde réel, les objets auxquels nous sommes confrontés sont des objets, comme des ordinateurs, des téléviseurs, des vélos, etc.
Il existe trois caractéristiques principales des objets :
Le comportement de l'objet : quelles opérations peuvent être appliquées à l'objet, allumer et éteindre la lumière sont des comportements.
La forme de l'objet : comment l'objet réagit lorsque ces méthodes sont appliquées, couleur, taille, apparence.
Représentation des objets : La représentation des objets équivaut à une carte d'identité, distinguant spécifiquement les différences dans un même comportement et un même statut.
Par exemple, Animal est une classe abstraite. Nous pouvons spécifier un chien et un mouton, et les chiens et les moutons sont des objets concrets. Ils ont des attributs de couleur, peuvent être écrits, peuvent courir et avoir d'autres états comportementaux.
Classe - définit les caractéristiques abstraites d'une chose. La définition d'une classe inclut la forme des données et les opérations sur les données.
Object - est une instance d'une classe.
Variables membres - Variables définies à l'intérieur d'une classe. La valeur de cette variable est invisible pour le monde extérieur, mais est accessible via les fonctions membres. Une fois la classe instanciée en tant qu'objet, la variable peut être appelée un attribut de l'objet.
Fonctions membres - sont définies à l'intérieur de la classe et peuvent être utilisées pour accéder aux données de l'objet.
Héritage - L'héritage est un mécanisme par lequel les sous-classes partagent automatiquement les structures de données et les méthodes de leur classe parent. Il s'agit d'une relation entre les classes. Lors de la définition et de l'implémentation d'une classe, vous pouvez le faire sur la base d'une classe existante, prendre le contenu défini par la classe existante comme votre propre contenu et ajouter du nouveau contenu.
Classe parent - Une classe héritée par d'autres classes peut être appelée classe parent, classe de base ou super classe.
Sous-classe - Une classe qui hérite d'autres classes est appelée une sous-classe, ou elle peut également être appelée une classe dérivée.
Polymorphisme - Le polymorphisme signifie que la même fonction ou méthode peut être appliquée à plusieurs types d'objets et obtenir des résultats différents. Différents objets peuvent produire des résultats différents lorsqu'ils reçoivent le même message. Ce phénomène est appelé polymorphisme.
Surcharge - En termes simples, il s'agit d'une situation dans laquelle des fonctions ou des méthodes ont le même nom mais des listes de paramètres différentes. De telles fonctions ou méthodes avec le même nom et des paramètres différents sont appelées fonctions ou méthodes surchargées.
Abstraction - L'abstraction fait référence à l'abstraction d'objets avec des structures de données (attributs) et des comportements (opérations) cohérents en classes. Une classe est une abstraction qui reflète les propriétés importantes liées à une application tout en ignorant les autres contenus non pertinents. La division de toute classe est subjective, mais doit être liée à l'application spécifique.
Encapsulation - L'encapsulation fait référence à la liaison des propriétés et du comportement d'un objet qui existe dans le monde réel et à son placement dans une unité logique.
Constructeur - est principalement utilisé pour initialiser l'objet lors de la création de l'objet, c'est-à-dire attribuer des valeurs initiales aux variables membres de l'objet. Il est toujours utilisé avec l'opérateur new dans l'instruction pour créer l'objet.
Destructor - Destructor (destructeur) Contrairement au constructeur, lorsque l'objet termine son cycle de vie (par exemple, la fonction dans laquelle se trouve l'objet a été appelée), le système exécute automatiquement le destructeur. Les destructeurs sont souvent utilisés pour effectuer un travail de "nettoyage" (par exemple, lors de la création d'un objet, utilisez new pour ouvrir un espace mémoire, qui doit être libéré avec delete dans le destructeur avant de quitter).
Dans la figure ci-dessous, nous avons créé trois objets via la classe Car : Mercedes, BMW et Audi.
$mercedes = nouvelle voiture ();$bmw = nouvelle voiture ();$audi = nouvelle voiture ();
Le format de syntaxe habituel pour les classes de définition PHP est le suivant :
<?phpclass phpClass { var $var1; var $var2 = "chaîne constante"; function myfunc ($arg1, $arg2) { [..] } [..]}?>L'analyse est la suivante :
Les classes sont définies à l'aide du mot-clé class suivi du nom de la classe.
Les variables et les méthodes peuvent être définies entre une paire d'accolades ({}) après le nom de la classe.
Les variables de classe sont déclarées à l'aide de var et les variables peuvent également être initialisées.
Les définitions de fonctions sont similaires aux définitions de fonctions PHP, mais les fonctions ne sont accessibles que via la classe et les objets qu'elle instancie.
<?phpclass Site { /* Variables membres*/ var $url; var $title; /* Fonctions membres*/ function setUrl($par){ $this->url = $par; } function getUrl(){ echo $this ->url . PHP_EOL; } function setTitle($par){ $this->title = $par; } function getTitle(){ echo $this->title . }}?>La variable $this représente son propre objet.
PHP_EOL est le caractère de nouvelle ligne.
Une fois qu'une classe est créée, nous pouvons utiliser l'opérateur new pour instancier les objets de cette classe :
$codercto = nouveau site ;$taobao = nouveau site ;$google = nouveau site ;
Dans le code ci-dessus, nous avons créé trois objets. Chacun des trois objets est indépendant. Voyons ensuite comment accéder aux méthodes membres et aux variables membres.
Après avoir instancié un objet, nous pouvons utiliser l'objet pour appeler des méthodes membres de l'objet. Les méthodes membres de l'objet ne peuvent opérer que sur les variables membres de l'objet :
// Appelez la fonction membre pour définir le titre et l'URL $codercto->setTitle( "Coder Tutorial" );$taobao->setTitle( "Taobao" );$google->setTitle( "Google Search" );$codercto- > setUrl( 'www.codercto.com' );$taobao->setUrl( 'www.taobao.com' );$google->setUrl( 'www.google.com' );// Appelez la fonction membre pour obtenir le titre et l'URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao-> getUrl( );$google->getUrl();
Le code complet est le suivant :
<?php class Site { /* Variables membres */ var $url ; var $title ; /* Fonctions membres */ function setUrl ( $par ){ $this -> url = $par } function getUrl (){ echo $ this -> url . PHP_EOL ; } function setTitle ( $par ){ $this -> title = $ par } function getTitle (){ echo $this - > titre . }} $codercto = new Site ; $taobao = new Site ; $google = new Site ; // Appeler la fonction membre, définir le titre et l'URL $ codercto - > setTitle ( " Tutoriel Coder " ); " ); $google -> setTitle ( "Recherche Google" ); $codercto -> setUrl ( 'www.codercto.com' ); $taobao -> setUrl ( 'www.taobao.com' ); $google -> setUrl ( 'www.google.com' ); // Appelez la fonction membre pour obtenir le titre et l'URL $codercto -> getTitle ( $taobao -> getTitle (); ); $google -> getTitle (); $ codercto -> getUrl (); $ taobao - > getUrl ( ) ;En exécutant le code ci-dessus, le résultat de sortie est :
Tutoriel Code Farmer Taobao Recherche Google www.codercto.comwww.taobao.comwww.google.com
Le constructeur est un type particulier de méthode. Il est principalement utilisé pour initialiser l'objet lors de la création de l'objet, c'est-à-dire attribuer des valeurs initiales aux variables membres de l'objet et l'utiliser avec new dans l'instruction pour créer l'objet.
PHP 5 permet aux développeurs de définir une méthode comme constructeur dans une classe, avec la syntaxe suivante :
void __construct ([ mixte $args [, $... ]] )
Dans l'exemple ci-dessus, nous pouvons initialiser les variables $url et $title via la méthode constructeur :
function __construct( $par1, $par2 ) { $this->url = $par1; $this->title = $par2;}Désormais, nous n'avons plus besoin d'appeler les méthodes setTitle et setUrl :
$codercto = nouveau site('www.codercto.com', 'Tutoriel Codeur');$taobao = nouveau site('www.taobao.com', 'Taobao');$google = nouveau site('www.google . com', 'Recherche Google');// Appelez la fonction membre pour obtenir le titre et l'URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao->getUrl(); $google ->getUrl();Destructeur (destructeur) Contrairement au constructeur, lorsque l'objet termine son cycle de vie (par exemple, la fonction dans laquelle se trouve l'objet a été appelée), le système exécute automatiquement le destructeur.
PHP 5 a introduit le concept de destructeurs, similaire aux autres langages orientés objet. Sa syntaxe est la suivante :
vide __destruct ( vide )
<?phpclass MyDestructableClass { function __construct() { print "constructorn"; $this->name = "MyDestructableClass"; } function __destruct() { print "destroy" . }$obj = new MyDestructableClass();?>En exécutant le code ci-dessus, le résultat de sortie est :
Le constructeur détruit MyDestructableClass
PHP utilise le mot-clé extends pour hériter d'une classe. PHP ne prend pas en charge l'héritage multiple. Le format est le suivant :
class Child étend Parent { // Partie code}Dans l'exemple, la classe Child_Site hérite de la classe Site et étend ses fonctions :
<?php // La classe enfant étend la classe de catégorie de site Child_Site étend le site { var $category; function setCate($par){ $this->category = $par } function getCate(){ echo $this->category . }}Si la méthode héritée de la classe parent ne peut pas répondre aux besoins de la sous-classe, elle peut être réécrite. Ce processus est appelé remplacement de méthode, également appelé réécriture de méthode.
Les méthodes getUrl et getTitle sont remplacées dans l'exemple :
function getUrl() { echo $this->url . return $this->url;} function getTitle(){ echo $this->title .Le contrôle d'accès de PHP aux propriétés ou méthodes est réalisé en ajoutant les mots-clés public (public), protected (protected) ou private (private) devant.
public : les membres de la classe publique sont accessibles de n’importe où.
protected : les membres de la classe protégée sont accessibles par eux-mêmes, ainsi que par leurs sous-classes et classes parentes.
Privé : les membres de la classe privée ne sont accessibles que par la classe dans laquelle ils sont définis.
Les attributs de classe doivent être définis comme étant publics, protégés ou privés. S'il est défini avec var, il est considéré comme public.
<?php/** * Définir MaClasse */class MaClasse{ 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 générera une erreur fatale echo $obj->private; // Cette ligne générera également une erreur fatale $obj->printHello(); // Sortie Public, Protected et Private/** * Define MyClass2 */ class MyClass2 extends MyClass{ // Public et protected peuvent être redéfinis, mais privés mais non protégés $protected = 'Protected2'; 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; set $obj2->protected; // Cette ligne générera une erreur fatale $obj2->printHello(); // Output Public, Protected2 et Undefined?>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/** * Define MyClass */class MyClass{ // Déclare un constructeur public public function __construct() { } // Déclare une méthode publique public function MyPublic() { } // Déclare une méthode protégée protected function MyProtected( ) { } // Déclare une méthode privée private function MyPrivate() { } // Cette méthode est une fonction publique Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); }}$myclass = new MyClass;$myclass->MyPublic(); // Cette ligne peut être exécutée normalement $myclass->MyProtected( //); Cette ligne générera une erreur fatale $myclass->MyPrivate(); // Cette ligne générera une erreur fatale $myclass->Foo(); // Public, protected et private peuvent tous être exécutés/** * Define MyClass2 */class MyClass2 extends MyClass{ // Cette méthode est une fonction publique Foo2() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); générer une erreur fatale}}$myclass2 = new MyClass2;$myclass2->MyPublic(); // Cette ligne peut être exécutée normalement $myclass2->Foo2( //); Les publics et les protégés peuvent être exécutés, mais les privés ne le peuvent pas. class Bar { public function test() { $this->testPrivate(); $this->testPublic( } public function testPublic() { echo "Bar : :testPublicn"; } fonction privée testPrivate() { echo "Bar::testPrivaten"; }}classe Foo étend Bar { fonction publique testPublic() { echo "Foo::testPublicn"; } fonction privée testPrivate() { echo "Foo::testPrivaten"; }}$myFoo = new foo();$myFoo->test(); // Foo::testPublic?>À l'aide d'une interface, vous pouvez spécifier les méthodes qu'une classe doit implémenter, mais vous n'avez pas besoin de définir le contenu spécifique de ces méthodes.
Une interface est définie via le mot-clé interface , tout comme la définition d'une classe standard, mais toutes les méthodes qui y sont définies sont vides.
Toutes les méthodes définies dans une interface doivent être publiques. C'est une caractéristique des interfaces.
Pour implémenter une interface, utilisez l’opérateur Implements . 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. Utilisez des virgules pour séparer les noms de plusieurs interfaces.
<?php// Déclarer une interface 'iTemplate' interface iTemplate{ public function setVariable($name, $var); public function getHtml($template);}// Implémenter la classe d'interface Template implémente iTemplate{ private $vars = array( ) ; fonction publique setVariable($nom, $var) { $this->vars[$nom] = $var; } fonction publique getHtml($template) { foreach($this->vars as $name => $value) { $template = str_replace('{' . $name . '}', $value, $template } return $template }}Les valeurs qui restent inchangées tout au long d'une classe peuvent être définies comme constantes. Il n'est pas nécessaire d'utiliser le symbole $ lors de la définition et de l'utilisation de constantes.
La valeur d'une constante doit être une valeur fixe et ne peut pas être une variable, un attribut de classe, le résultat d'une opération mathématique ou un appel de fonction.
Depuis PHP 5.3.0, les classes peuvent être appelées dynamiquement à l'aide d'une variable. Mais la valeur de cette variable ne peut pas être un mot-clé (comme self, parent ou static).
<?phpclass MaClasse{ const constant = 'valeur constante'; function showConstant() { echo self::constant . PHP_EOL; // Depuis 5.3.0 $class = nouveau MaClasse();$class->showConstant();echo $class::constant . PHP_EOL // Depuis PHP 5.3.0 ?>Toute classe doit être déclarée abstraite si au moins une méthode qu'elle contient est déclarée abstraite.
Les classes définies comme abstraites ne peuvent pas être instanciées.
Une méthode définie comme abstraite déclare uniquement sa méthode appelante (paramètres) et ne peut pas définir son implémentation de fonction spécifique.
Lors de l'héritage d'une classe abstraite, la sous-classe doit définir toutes les méthodes abstraites de la classe parent ; de plus, le contrôle d'accès de ces méthodes doit être le même (ou plus assoupli) que dans la classe parent. 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.
<?phpabstract class AbstractClass{ // Obligatoire pour les sous-classes de définir ces méthodes abstract protected function getValue(); abstract protected function prefixValue($prefix); // Méthode ordinaire (méthode non abstraite) public function printOut() { print $this); ->getValue() . PHP_EOL; }}class ConcreteClass1 extends AbstractClass{ protected function getValue() { return "ConcreteClass1" } fonction publique; 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_') .En exécutant le code ci-dessus, le résultat de sortie est :
ConcreteClass1FOO_ConcreteClass1ConcreteClass2FOO_ConcreteClass2
De plus, les méthodes de classe enfant peuvent contenir des paramètres facultatifs qui ne sont pas présents dans la méthode abstraite de classe parent.
Par exemple, si une sous-classe définit un paramètre facultatif qui n'est pas inclus dans la déclaration de la méthode abstraite de la classe parent, elle peut toujours s'exécuter normalement.
<?phpabstract class AbstractClass{ // Notre méthode abstraite n'a besoin que de définir les paramètres requis abstract protected function prefixName($name);}class ConcreteClass extends AbstractClass{ // Notre sous-classe peut définir des options facultatives qui n'existent pas dans la signature de la classe parent Paramètres public function prefixName($name, $separator = ".") { if ($name == "Pacman") { $prefix = "Mr" } elseif ($name == "Pacwoman") { $prefix = "Mme"; } else { $prefix = ""; } return "{$prefix}{$separator} {$name}" }}$class = new ConcreteClass;echo $class->prefixName("Pacman "), "n";echo $class->prefixName("Pacwoman"), "n";?>Le résultat est :
M. PacmanMme Pacwoman
En déclarant un attribut ou une méthode de classe comme statique, vous pouvez y accéder directement sans instancier la classe.
Les propriétés statiques ne sont pas accessibles via un objet d'une classe qui a été instanciée (mais les méthodes statiques le peuvent).
Étant donné que les méthodes statiques ne nécessitent pas l’appel d’un objet, la pseudo variable $this n’est pas disponible dans les méthodes statiques.
Les propriétés statiques ne sont pas accessibles aux objets via l'opérateur ->.
Depuis PHP 5.3.0, les classes peuvent être appelées dynamiquement à l'aide d'une variable. Mais la valeur de cette variable ne peut pas être les mots-clés self, parent ou static.
<?phpclass Foo { public static $my_static = 'foo'; public function staticValue() { return self::$my_static; }}print Foo::$my_static . >staticValue() .PHP_EOL;?>En exécutant le programme ci-dessus, le résultat de sortie est :
foofoo
PHP 5 ajoute un nouveau mot-clé final. Si une méthode de la classe parent est déclarée finale, la classe enfant ne peut pas remplacer la méthode. Si une classe est déclarée finale, elle ne peut pas être héritée.
Une erreur sera signalée lors de l'exécution du code suivant :
<?phpclass BaseClass { public function test() { echo "BaseClass::test() appelé" } final public function moreTesting() { echo "BaseClass::moreTesting() appelé" }}class ChildClass extends. BaseClass { public function moreTesting() { echo "ChildClass::moreTesting() appelé" }}// Message d'erreur Erreur fatale : Impossible de remplacer la méthode finale BaseClass::moreTesting()?>PHP n'appellera pas automatiquement le constructeur de la classe parent dans le constructeur de la classe enfant. Pour exécuter le constructeur de la classe parent, vous devez appeler parent::__construct() dans le constructeur de la classe enfant.
<?phpclass BaseClass { function __construct() { print "Méthode constructeur dans la classe BaseClass" . PHP_EOL; }}class SubClass extends BaseClass { function __construct() { parent::__construct(); La méthode constructeur de la classe print "Méthode constructeur dans la classe SubClass" . PHP_EOL; }}class OtherSubClass extends BaseClass { // Hériter de la méthode constructeur de BaseClass}// Appelez le constructeur BaseClass $obj = new BaseClass(); // Appelez les constructeurs BaseClass et SubClass $obj = new SubClass(); // Appelez le constructeur BaseClass $obj = new OtherSubClass();?>En exécutant le programme ci-dessus, le résultat de sortie est :
Méthode constructeur dans la classe BaseClass Méthode constructeur dans la classe SubClass Méthode constructeur dans la classe BaseClass