PHP orienté objet

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. C'est une abstraction du monde réel.

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

Les trois principales caractéristiques de l'objet :

· Le comportement de l'objet : quelles opérations peuvent être appliquées à l'objet , allumez les lumières, éteignez les lumières La lumière est l'action.

· La forme de l'objet : comment l'objet répond, sa couleur, sa taille et son apparence lorsque ces méthodes sont appliquées.

· Représentation des objets : La représentation des objets équivaut à une carte d'identité. Elle distingue spécifiquement les différences entre les mêmes comportements et états.

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 d'autres états comportementaux.

Contenu orienté objet

· 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 de la 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.

· Fonction membre - Définie à l'intérieur de la classe, elle peut être utilisée pour accéder aux données de l'objet.

· Héritage - L'héritage est un mécanisme permettant aux sous-classes de partager automatiquement les structures de données et les méthodes des classes parentes. 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 est héritée par d'autres classes. Cette classe peut être appelée une classe parent, une classe de base ou une 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 opération, fonction ou processus peut être appliqué à 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 existant dans le monde réel et à son placement dans une unité logique.

· Constructeur - 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 = voiture neuve ();

$bmw = voiture neuve ();

$audi = voiture neuve () ;

Définition de classe PHP

PHP Le format de syntaxe habituel pour définir une classe est le suivant :

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

est analysé comme suit :

· Utilisation de la classe Ajoutez la définition du nom de classe après le mot-clé class.

· 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.

· La définition de fonction est similaire à la définition de fonction PHP, mais les fonctions ne sont accessibles que via la classe et ses objets instanciés.

Instance

<?php
 class Site {
     /* 成员变量 */
     var $url;
     var $title;
 
     /* 成员函数 */
     function setUrl($par){
         $this->url = $par;
     }
 
     function getUrl(){
         echo $this->url ."<br/>";
     }
 
     function setTitle($par){
         $this->title = $par;
     }
 
     function getTitle(){
         echo $this->title . "<br/>";
     }
 }?>

La variable $this représente l'objet d'elle-même.

Création d'objets en PHP

Une fois la classe créée, nous pouvons utiliser l'opérateur new pour instancier les objets de cette classe :

$php = nouveau site;

$taobao = nouveau site;

$google = nouveau site;

Nous avons créé trois objets dans le code ci-dessus. Chacun des trois objets est indépendant. Voyons ensuite comment accéder aux méthodes membres et aux variables membres.

// Appeler la fonction membre, définir le titre et l'URL

$php->setTitle( "php中文网" );
$taobao-> setTitle( "Taobao" );
$google->setTitle( "Recherche Google" );

$php->setUrl( 'www.php.cn' );
$taobao ->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

// Appelez la fonction membre pour obtenir le titre et URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();

$php->getUrl( );
$taobao->getUrl();
$google->getUrl();

Nous combinons les codes que nous avons appris ci-dessus :

Le code complet est le suivant :

<?php
 header("Content-type:text/html;charset=utf-8");    //设置编码
 class Site {
     /* 成员变量 */
     var $url;
     var $title;
 
     /* 成员函数 */
     function setUrl($par){
         $this->url = $par;
     }
 
     function getUrl(){
         echo $this->url ."<br/>";
     }
 
     function setTitle($par){
         $this->title = $par;
     }
 
     function getTitle(){
         echo $this->title . "<br/>";
     }
 }
 
 $php = new Site;
 $taobao = new Site;
 $google = new Site;
 
 // 调用成员函数，设置标题和URL
 $php->setTitle( "php中文网" );
 $taobao->setTitle( "淘宝" );
 $google->setTitle( "Google 搜索" );
 
 $php->setUrl( 'www.php.cn' );
 $taobao->setUrl( 'www.taobao.com' );
 $google->setUrl( 'www.google.com' );
 
 // 调用成员函数，获取标题和URL
 $php->getTitle();
 $taobao->getTitle();
 $google->getTitle();
 
 $php->getUrl();
 $taobao->getUrl();
 $google->getUrl();
 ?>

Résultats en cours d'exécution du programme :

Site Web chinois php
Taobao
Recherche Google
www.php.cn
www.taobao.com
www .google.com

Constructeur PHP

Le constructeur est une méthode spéciale. Il est principalement utilisé pour initialiser l'objet lors de la création de l'objet, c'est-à-dire pour 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.

PHP 5 permet aux développeurs de définir une méthode comme constructeur dans une classe. Le format de syntaxe est le suivant :

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

Dans l'exemple ci-dessus, nous pouvons initialiser $url et $title via les variables du constructeur :

fonction __construct( $par1, $par2 ) {

$this->url = $par1;

$ this- >title = $par2;

}

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

Instance

Utilisez le constructeur pour simplifier le code ci-dessus :

<?php
 header("Content-type:text/html;charset=utf-8");    //设置编码
 class Site {
     /* 成员变量 */
     var $url;
     var $title;
 
     /* 成员函数 */
     function setUrl($par){
         $this->url = $par;
     }
 
     function getUrl(){
         echo $this->url ."<br/>";
     }
 
     function setTitle($par){
         $this->title = $par;
     }
 
     function getTitle(){
         echo $this->title . "<br/>";
     }
     function __construct( $par1, $par2 ) {
         $this->url = $par1;
         $this->title = $par2;
     }
 }
 
 // 调用成员函数，设置标题和URL
 $php = new Site('www.php.cn', 'php中文网');
 $taobao = new Site('www.taobao.com', '淘宝');
 $google = new Site('www.google.com', 'Google 搜索');
 
 // 调用成员函数，获取标题和URL
 $php->getTitle();
 $taobao->getTitle();
 $google->getTitle();
 
 $php->getUrl();
 $taobao->getUrl();
 $google->getUrl();
 ?>

Résultat de l'exécution du programme :

site Web chinois php
Taobao
Recherche Google
www.php.cn
www.taobao.com
www.google.com

Constructeur d'analyse

Destructeur (destructeur) Contrairement au constructeur, lorsque l'objet termine son cycle de vie (comme la fonction dans laquelle le l'objet localisé a été appelé), le système exécute automatiquement le destructeur.

PHP 5 a introduit le concept de destructeur, qui est similaire à d'autres langages orientés objet. Son format de syntaxe est le suivant :

void __destruct (void). )

Instance

<?php
 header("Content-type:text/html;charset=utf-8");    //设置编码
 class MyDestructableClass {
     function __construct() {
         print "构造函数\n";
         $this->name = "MyDestructableClass";
     }
 
     function __destruct() {
         print "销毁 " . $this->name . "\n";
     }
 }
 
 $obj = new MyDestructableClass();
 ?>

Résultat d'exécution du programme :

Constructeur Destroy MyDestructableClass

Inherit

PHP utilise le mot-clé extends pour hériter d'une classe, PHP ne prend pas en charge l'héritage multiple, format Comme suit :

classe Enfant étend Parent {

// Partie code

}

Ci-dessus Cela signifie que la classe Child hérite de la classe Parent

Instance

Dans l'exemple suivant, la classe Child_Site hérite de la classe Site et étend la fonctionnalité :

<?php
// 子类扩展站点类别
class Child_Site extends Site {
    var $category;
    function setCate($par){
        $this->category = $par;
    }
    function getCate(){
        echo $this->category . "<br/>";
    }
}
?>

Réécriture de méthode

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éécrit, ce processus est appelé remplacement de méthode, également connu sous le nom de réécriture de méthode.

L'exemple suivant réécrit les méthodes getUrl et getTitle :

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.

 : les membres de la classe publique sont accessibles de n'importe où. · protected  : les membres de la classe protégés sont accessibles par eux-mêmes, ainsi que par leurs sous-classes et classes parentes.

·

 : les membres de la classe privée ne sont accessibles que par la classe dans laquelle ils sont définis. Contrôle d'accès des attributs

Les attributs de classe doivent être définis comme étant publics, protégés et privés. S'il est défini avec var, il est considéré comme public.

Instance

<?php
 /**
  * Define 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; // 这行能被正常执行
 echo $obj->protected; // 这行会产生一个致命错误
 echo $obj->private; // 这行也会产生一个致命错误
 $obj->printHello(); // 输出 Public、Protected 和 Private
 
 
 /**
  * Define MyClass2
  */
 class MyClass2 extends MyClass
 {
     // 可以对 public 和 protected 进行重定义，但 private 而不能
     protected $protected = 'Protected2';
 
     function printHello()
     {
         echo $this->public;
         echo $this->protected;
         echo $this->private;
     }
 }
 
 $obj2 = new MyClass2();
 echo $obj2->public; // 这行能被正常执行
 echo $obj2->private; // 未定义 private
 echo $obj2->protected; // 这行会产生一个致命错误
 $obj2->printHello(); // 输出 Public、Protected2 和 Undefined
 
 ?>

Regardez attentivement le code ci-dessus

Méthode de contrôle d'accès

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. Instance

<?php
 /**
  * Define MyClass
  */
 class MyClass
 {
     // 声明一个公有的构造函数
     public function __construct() { }
 
     // 声明一个公有的方法
     public function MyPublic() { }
 
     // 声明一个受保护的方法
     protected function MyProtected() { }
 
     // 声明一个私有的方法
     private function MyPrivate() { }
 
     // 此方法为公有
     function Foo()
     {
         $this->MyPublic();
         $this->MyProtected();
         $this->MyPrivate();
     }
 }
 
 $myclass = new MyClass;
 $myclass->MyPublic(); // 这行能被正常执行
 $myclass->MyProtected(); // 这行会产生一个致命错误
 $myclass->MyPrivate(); // 这行会产生一个致命错误
 $myclass->Foo(); // 公有，受保护，私有都可以执行
 
 
 /**
  * Define MyClass2
  */
 class MyClass2 extends MyClass
 {
     // 此方法为公有
     function Foo2()
     {
         $this->MyPublic();
         $this->MyProtected();
         $this->MyPrivate(); // 这行会产生一个致命错误
     }
 }
 
 $myclass2 = new MyClass2;
 $myclass2->MyPublic(); // 这行能被正常执行
 $myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行
 
 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
 ?>

Utiliser l'interface (interface), vous pouvez spécifier quelles méthodes une certaine classe doit implémenter, mais vous n'avez pas besoin de définir le contenu spécifique de ces méthodes.

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, 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.

Instance

<?php
// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}
// 实现接口
class Template implements iTemplate
{
    private $vars = array();
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
        return $template;
    }
}
?>

Constante

Vous pouvez définir des valeurs qui restent inchangées dans une classe 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, vous pouvez utiliser une variable pour appeler dynamiquement une classe. Mais la valeur de cette variable ne peut pas être un mot-clé (comme self, parent ou static).

Instance

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

Classe abstraite

tout Une classe doit être déclarée abstraite si au moins une méthode qu'elle contient est déclarée abstraite.

Une classe définie comme abstraite ne peut pas être instanciée.

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 que celui de la classe parent (ou plus détendu). ). 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. De plus, les méthodes d'appel doivent correspondre, c'est-à-dire que le type et le nombre de paramètres requis doivent être cohérents. Par exemple, si la sous-classe définit un paramètre facultatif

mais qu'il n'est pas inclus dans la déclaration de la méthode abstraite de la classe parent, il n'y a pas de conflit entre les deux déclarations.

Instance

<?php
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_') . "<br/>";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . "<br/>";
?>

Résultat en cours d'exécution du programme :

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

Mot-clé statique

déclare un attribut ou une méthode de classe comme static (static), 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, vous pouvez 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.

Instance

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

Résultat de l'exécution du programme :

foo
foo

Mot clé final

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.

Instance

L'exécution du code suivant signalera 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;
     }
 }
 // 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
 ?>

Résultat de l'exécution du programme :

Erreur fatale : impossible de remplacer la méthode finale BaseClass::moreTesting() dans D:WWWBasisoopopp_9.php à la ligne 16

Appeler la méthode du constructeur de classe parent

PHP n'appellera pas automatiquement le constructeur de la classe parent dans le constructeur de la sous-classe. Pour exécuter le constructeur de la classe parent, vous devez appeler parent::__construct()

Instance

<?php
 header("Content-type:text/html;charset=utf-8");    //设置编码
 class BaseClass {
     function __construct() {
         print "BaseClass 类中构造方法" . "<br/>";
     }
 }
 class SubClass extends BaseClass {
     function __construct() {
         parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
         print "SubClass 类中构造方法" . "<br/>";
     }
 }
 class OtherSubClass extends BaseClass {
     // 继承 BaseClass 的构造方法
 }
 
 // 调用 BaseClass 构造方法
 $obj = new BaseClass();
 
 // 调用 BaseClass、SubClass 构造方法
 $obj = new SubClass();
 
 // 调用 BaseClass 构造方法
 $obj = new OtherSubClass();
 ?>

< dans le constructeur de la sous-classe 🎜>Résultats d'exécution du programme :

Méthode constructeur dans la classe BaseClass

Méthode constructeur dans la classe BaseClass
Méthode constructeur dans la classe SubClass
Méthode constructeur dans la classe BaseClass