PHP orienté objet

En programmation orientée objet (anglais : Programmation orientée objet, abréviation : OOP), An L'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.

Recommandations d'apprentissage associées : "Programmation orientée objet PHP (Jade Girl Heart Sutra Edition)", "Démarrage rapide de la programmation orientée objet MySQL "

Les trois principales caractéristiques de l'objet :

• Le comportement de l'objet : quelles opérations peuvent être appliquées à l'objet, tourner les lumières allumées et éteintes sont les comportements.

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

• Représentation d'objet : La représentation d'objet é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 et peuvent être écrits, vous pouvez 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 − est définie à l'intérieur de la classe et 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 de la 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 est héritée par d'autres classes. Cette classe peut être appelée classe parent, ou classe de base, ou super classe.

• Sous-classe - Une classe qui hérite d'autres classes est appelée une sous-classe ou 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 où 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 portent le même nom mais sont différentes. paramètres Ils s'appellent des fonctions ou des 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é ensemble. avec l'opérateur new pour créer l'objet dans l'instruction.

• Destructeur − 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. 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 l'image ci-dessous, 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 classe PHP

La classe de définition PHP a généralement le format de syntaxe suivant :

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

• 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 la classe

• sont déclarées à l'aide de var, et les variables peuvent également être initialisées avec des valeurs.

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

Instance

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;
  
  /* 成员函数 */
  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;
  }
}
?>

PHP_EOL est le caractère de nouvelle ligne.

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 = new Site;
$taobao = new Site;
$google = new Site;

Appeler des méthodes membres

Après avoir instancié un objet, nous pouvons utiliser l'objet pour appeler des méthodes membres. Les méthodes membres de l'objet ne peuvent opérer que les variables membres de l'objet :

Appelez la fonction membre, définissez le titre et l'URL

$php->setTitle( "php中文网" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );
$php->setUrl( 'www.php.cn' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

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

Code complet comme suit :

<?php 
class Site { 
  /* 成员变量 */ 
  var $url; 
  var $title; 
   
  /* 成员函数 */ 
  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; 
  } 
} 

$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(); 
?>

Exécutez le code ci-dessus, le résultat de sortie est :

php中文网
淘宝
Google 搜索
www.php.cn
www.taobao.com
www.google.com

Constructeur PHP

Constructor 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 en tant que constructeur dans une classe. Le format de syntaxe est le suivant :

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

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

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;

  function __construct( $par1, $par2 ) {
    $this->url = $par1;
    $this->title = $par2;
  }
  /* 成员函数 */
  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;
  }
}

$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();
?>

Destructeur

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 destructeur, qui est similaire à d'autres langages orientés objet. Son format de syntaxe est le suivant :

void __destruct ( void )

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

构造函数
销毁 MyDestructableClass

extends pour hériter d'une classe. PHP ne prend pas en charge l'héritage multiple. Le format est le suivant :

class Child extends Parent {
   // 代码部分
}

La classe Child_Site dans l'exemple hérite de la classe Site et étend les fonctions :

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

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'instance :

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

PHP pour les attributs ou Le contrôle d'accès aux méthodes est réalisé en ajoutant les mots-clés public, protected ou 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 lui-même et par ses sous-classes et classes parentes.

• privé (privé) :

  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.

<?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
?>

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
{
    // 声明一个公有的构造函数
    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
?>

À l'aide d'une interface, vous pouvez spécifier quelles méthodes une classe doit implémenter, mais vous n'avez pas besoin de définir eux Le contenu spécifique de la méthode. L'interface

est définie via le mot-clé

, 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 l'interface doivent être publiques. C'est une caractéristique de l'interface.

Pour implémenter une interface, utilisez l'opérateur

. 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
// 声明一个'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;
    }
}

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

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);
    // 普通方法（非抽象方法）
    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;
?>

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

<?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;
?>

foo
foo

<?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()
?>

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法