PHP orientée objet

Dans la programmation orientée objet (en anglais: la programmation orientée-objet, Abréviation: POO), l'objet est une description de l'information et de traitement de l'information consistant en un ensemble, est l'abstraction réelle du monde.

Les choses sont des objets dans le monde réel que nous sommes confrontés, tels que des ordinateurs, des téléviseurs, des vélos.

Trois caractéristiques majeures de l'objet:

• Comportement de l'objet: un objet qui peut être appliqué à l'opération, allumer les lumières, éteindre les lumières est un comportement.
• objet Form: Lors de l'application de ces méthodes est la façon de répondre à l'objet, la couleur, la taille, la forme.
• Représentation de l'objet: un objet représentant l'équivalent de l'identité, de distinguer précisément ce qui est différent dans le même comportement et de l'état.

Par exemple, des animaux (animal) est une classe abstraite, nous peut être spécifique à un mouton avec un chien, et le chien avec les moutons est une cible spécifique, ils ont un attribut de couleur, vous pouvez écrire, vous pouvez exécuter d'autres actes de l'État.

contenu orienté objet

• Classe - définit les caractéristiques abstraites d'une chose.définition de classe contient les données de formulaires et les opérations sur les données.

• Objets - est une instance de la classe.

• Lesvariables membres - des variables définies dans la classe.La valeur externe de la variable ne soit pas visible, mais peut être consulté par les fonctions membres, après la classe est instanciée comme un objet, les propriétés de l'objet peut être appelé une variable.

• fonction de membre - définie à l' intérieur de la classe peut être utilisée pour les objets d'accès aux données.

• Héritage - Héritage est une sous - classe de partage automatique des structures et des méthodes de la classe parente, ce qui est une relation entre les classes données.Dans la définition et la mise en œuvre d'une classe, ils peuvent venir dans une telle base existe déjà effectué, cette classe déjà existante telle que définie par le contenu de leur contenu, et d'ajouter un nouveau contenu.

• classe Parent - une classe héritée par d' autres classes, la classe peut être appelé le parent classe, de groupe ou de classe, ou superclasse.

• Sous - catégorie- une classe qui hérite une autre classe est appelée une sous - classe peut aussi être appelé une classe dérivée.

• Polymorphisme - polymorphisme se réfère à la même opération ou une fonction, le procédé peut être appliqué aux plusieurs types d'objets et d' obtenir des résultats différents.Différents objets, vous recevez le même message peut produire des résultats différents, ce phénomène est appelé polymorphisme.

• Surcharge - bref, il est une fonction ou une méthode avec le même nom, mais la liste des paramètres ne sont pas la même situation, une telle fonction ou méthode entre les différents paramètres du même nom, chaque fonction surchargée ou méthode est appelée.

• Résumé - Le résumé se réfère à avoir une structure cohérente de données (attributs) et le comportement (opérations) des objets dans les classes.Une telle classe est une abstraction, elle reflète les propriétés importantes associées à l'application, tout en ignorant d'autres contenus sans rapport. Toute division de classe est subjective, mais doit être liée à l'application spécifique.

• Package - Package se réfère aux propriétés et le comportement d'un objet dans le monde réel existe pour lier ensemble et placé dans une unité logique.

• Constructor - principalement utilisé pour initialiser l'objet lorsque vous créez un objet, l'objet est attribué une valeur initiale de la variable membre, utilisez toujours la déclaration de création d'objets avec le nouvel opérateur.

• Destructor - destructor (destructor) et le constructeur En revanche, lorsque la fin de l' objet de son cycle de vie (par exemple, où l'objet est un appel de fonction est terminée), le système effectue automatiquement destructor.Destructeurs sont souvent utilisés pour faire «nettoyer la suite de« travail (par exemple, lorsque vous créez un objet avec une nouvelle ouverture de l'espace mémoire doit être utilisée avant de sortir dans le destructor supprimer la libération).

La figure suivante nous créons trois objets classe Voiture: Mercedes, Bmw, et Audi.

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

définition de classe PHP

PHP classe personnalisée habituellement syntaxe est la suivante:

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

Interprété comme suit:

• Après la classe en utilisantle mot - clé de classeainsi que le nom de la définition de la classe.

• Une paire d'accolades après le nom de la classe peut définir des variables et des méthodes ({}) à l'intérieur.

• Les variables de classe en utilisantvar pour déclarer des variables peuvent aussi être initialisés valeurs.

• PHP définition de la fonction est similaire à la définition de la fonction, mais la fonction est accessible uniquement par la classe et ses objets instanciés.

Exemples

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

$ Cette variable représentent leurs objets.

newlinePHP_EOL.

PHP pour créer des objets

Après la classe est créée, nous pouvons utiliser lenouvel opérateur pour instancier un objet de la classe:

$w3big = new Site;
$taobao = new Site;
$google = new Site;

Le code ci-dessus, nous créons trois objets, chacun des trois objets sont indépendants, alors nous regardons comment accéder à des méthodes membres et variables membres.

Appelle la méthode membre

Une fois l'objet est instancié, nous pouvons utiliser l'objet d'appeler une méthode de membre, la méthode de l'objet ne peut être un membre de la variable d'élément de commande de l'objet:

// 调用成员函数，设置标题和URL
$w3big->setTitle( "本教程" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );

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

// 调用成员函数，获取标题和URL
$w3big->getTitle();
$taobao->getTitle();
$google->getTitle();

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

Le code complet est le suivant:

Mise en œuvre du code ci-dessus, la sortie est:

本教程
淘宝
Google 搜索
www.w3big.com
www.taobao.com
www.google.com

PHP Constructor

Constructor est une méthode spéciale. Principalement utilisé pour initialiser l'objet lorsque vous créez un objet, l'objet est attribué une valeur initiale de la variable membre, utilisez toujours la déclaration de création d'objets avec le nouvel opérateur.

PHP 5 permet aux développeurs de définir une méthode ligne dans une classe comme une syntaxe du constructeur est la suivante:

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

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

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

Maintenant, nous ne devons pas appeler la méthode setTitle et setUrl:

destructor

Destructor (destructor) et le constructeur En revanche, lorsque la fin de l'objet de son cycle de vie (par exemple, où l'objet est un appel de fonction est terminée), le système effectue automatiquement destructor.

PHP 5 introduit le concept d'un destructor, qui est similaire à d'autres langages orientés objet, la syntaxe est la suivante:

void __destruct ( void )

Exemples

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

   function __destruct() {
       print "销毁 " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

Mise en œuvre du code ci-dessus, la sortie est:

构造函数
销毁 MyDestructableClass

hériter

PHP mot - cléextends pour hériter une classe, PHP ne supporte pas l' héritage multiple, dans le format suivant:

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

Exemples

classe Exemple Child_Site hérite de la classe de site, et étend la fonctionnalité:

<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

	function setCate($par){
		$this->category = $par;
	}
  
	function getCate(){
		echo $this->category . PHP_EOL;
	}
}

remplacements Méthode

Si vous ne pouvez pas répondre aux besoins d'une sous-classe hérite de la méthode de la classe parent, il peut être réécrite, un processus appelé overlay méthode (override), aussi connu comme la méthode dominante.

Exemple réécrite GetURL et getTitle méthodes:

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

Contrôle d'accès

PHP sur la propriété ou la méthode de contrôle d'accès est obtenue en ajoutant des mots-clés devant le public (public), protégé (protégée) ou privée (privée) à atteindre.

• publique (Public): membre de la classe publique est accessible partout.
• protégé (protégé): membre de la classe protégée est accessible par son propre ainsi que sa sous-classe et la classe parente.
• privé (privé): les membres du groupe privé ne sont accessibles que lorsque la définition de classe.

attributs de contrôle d'accès

attribut de classe doit être définie comme protégée, l'un public et privé. Si elle est définie avec le 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

?>

méthodes de contrôle d'accès

Méthode dans la classe peut être définie comme public, privé ou protégé. Si vous ne définissez pas ces mots-clés, la méthode par défaut public.

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

interface

Utilisation de l'interface (interface), vous pouvez spécifier quelles méthodes une classe doit mettre en œuvre, mais ne pas avoir besoin de définir le contenu spécifique de ces méthodes.

L'interface est définie parle mot - clé interface,comme la définition d'une classe standard, mais qui définit toutes les méthodes sont vides.

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

Pour implémenter une interface, utilisez l'opérateurimplements.La classe doit implémenter toutes les méthodes définies dans une interface, ou bien va signaler une erreur fatale. 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;
    }
}

constante

Vous pouvez mettre dans la classe reste les mêmes valeurs définies comme des constantes. Dans la définition et l'utilisation des constantes de temps ne pas besoin d'utiliser le symbole $.

La valeur de la constante doit être une valeur fixe, pas une variable, les attributs de classe, les résultats de mathématiques ou de la fonction d'appel.

Depuis PHP 5.3.0 partir, vous pouvez utiliser une variable d'appeler dynamiquement la classe. Mais la valeur de la variable ne peut pas être un mot-clé (par exemple self, parent ou statique).

Exemples

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

classe abstraite

Toute classe, si elle contient au moins une méthode est déclarée abstraite, cette classe doit être déclarée comme abstraite.

Est défini comme une classe abstraite ne peut pas être instanciée.

Est défini comme une méthode abstraite ne déclare son invocation (paramètres), vous ne pouvez pas définir la mise en œuvre de la fonction spécifique.

Hériter une classe abstraite, sous-classe doit tous abstraits classe parent méthode définitions; En outre, l'accès à ces méthodes de contrôle et de la classe parent doit être le même que (ou plus détendu). Par exemple, une méthode abstraite est déclarée protégée, le procédé mis en oeuvre dans la sous-classe doit être déclarée comme protégée ou publique, mais ne peut pas être défini comme privé. Aussi appelé par la méthode doit correspondre, qui est le type et le nombre de paramètres requis doivent être cohérents. Par exemple, une sous-classe définit un paramètre optionnel, et la déclaration de la méthode abstraite de la classe parent il n'y a pas, alors il n'y a pas de conflit entre les deux déclarations.

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

Mise en œuvre du code ci-dessus, la sortie est:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

statique

Déclarez des propriétés ou des méthodes de classe comme statique (statique), vous ne pouvez pas instancier la classe et un accès direct.

Propriété statique par une classe ne peut pas être instancié objet d'accès (mais la méthode statique peut).

Comme les méthodes statiques ne sont pas tenus d'appeler à travers l'objet, la pseudo-variable $ ce ne sont pas disponibles dans une méthode statique.

Pour accéder à l'opérateur> - Propriété statique non par le sujet.

Depuis PHP 5.3.0 partir, vous pouvez utiliser une variable d'appeler dynamiquement la classe. Mais la valeur de la variable peut ne pas être un mot-clé self, d'un parent ou statique.

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

Le programme ci-dessus, le résultat est:

foo
foo

Mot final

PHP 5 ajoute un mot-clé final. Si la méthode de la classe parent est déclarée définitive, la sous-classe ne peut pas remplacer cette méthode. Si une classe est déclarée définitive, il ne peut pas être héritée.

L'erreur d'exécution de code suivant:

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

Appelez le constructeur de la classe parent

PHP ne remet pas automatiquement le constructeur du constructeur de la classe parent dans la sous-classe. Pour exécuter le constructeur de la classe parent, nous avons besoin d'appeler leparent dans le constructeur de la sous - classe :: __ construct ().

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

Le programme ci-dessus, le résultat est:

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