PHP orienté objet

>

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éécrite , ce processus est appelé remplacement de méthode, également appelé réécriture de méthode.

Les méthodes getUrl et getTitle sont réécrites dans l'instance :

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.

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 les méthodes qu'une classe doit implémenter, mais pas les détails de ces méthodes doivent être définies.

<?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 une valeur qui reste toujours inchangée dans une classe comme constante. 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 . 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

N'importe quelle classe s'il y en a au moins une dedans Si la méthode est déclarée abstraite, alors la classe doit être 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 dans la classe parent ; de plus, le contrôle d'accès de ces méthodes doit être le même (ou plus détendu) 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. 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 une sous-classe définit un paramètre facultatif qui n'est pas inclus dans la déclaration d'une méthode abstraite de la classe parent, 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;
?>

exécute le code ci-dessus et le résultat de sortie est :

ConcreteClass1

FOO_ConcreteClass1

ConcreteClass2

FOO_ConcreteClass2

Mot-clé statique

Déclarez un attribut ou une méthode de classe comme statique (static), et vous pourrez 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.

<?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écutez le programme ci-dessus, le résultat de sortie est :

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.

Le code suivant signalera une erreur lors de son exécution :

<?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 le fait pas. Le constructeur de la classe parent sera automatiquement appelé dans le constructeur de la sous-classe. Pour exécuter le constructeur de la classe parent, vous devez appeler parent::__construct() dans le constructeur de la classe enfant.

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

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

Méthode de construction dans la classe BaseClass

Méthode de construction dans la classe BaseClass

Méthode de construction dans la classe SubClass

Méthode de construction dans la classe BaseClass