Quelle est la différence entre l'interface et la classe abstraite en php

La différence est la suivante : 1. L'interface est définie via le mot-clé interface et la classe abstraite est définie via le mot-clé abstract ; 2. L'interface n'a pas de membres de données, mais la classe abstraite a des membres de données, et la classe abstraite peut implémenter l'encapsulation des données ; 3. L'interface n'a pas de constructeur, mais la classe abstraite peut avoir un constructeur.

L'environnement d'exploitation de ce tutoriel : système windows7, version PHP7.1, ordinateur DELL G3

1. Différences des interfaces

Lorsque vous apprenez le PHP orienté objet, vous serez toujours confus au sujet des classes abstraites et des interfaces. Pourquoi sont-elles si faciles à confondre alors qu'elles ont presque les mêmes fonctions ? débarrassé de l'autre ? Mais en fait, la différence entre les deux est encore très grande. Si vous parvenez à faire bon usage des deux méthodes de PHP, la programmation orientée objet sera plus raisonnable, claire et efficace.

a. L'interface est définie via le mot-clé interface et la classe abstraite est définie via le mot-clé abstract.
b. L'utilisation des interfaces est réalisée via le mot-clé Implements, tandis que le fonctionnement des classes abstraites est implémenté à l'aide du mot-clé extends de l'héritage de classe.
c. Les interfaces n'ont pas de données membres, mais les classes abstraites ont des données membres et les classes abstraites peuvent encapsuler des données.
d. Les interfaces n'ont pas de constructeurs et les classes abstraites peuvent avoir des constructeurs.
e. Les méthodes de l'interface sont toutes de type public, tandis que les méthodes de la classe abstraite peuvent être modifiées avec private, protected ou public.
f.Une classe peut implémenter plusieurs interfaces en même temps, mais ne peut implémenter qu'une seule classe abstraite.

Même point : rien ne peut être écrit dans les corps de fonctions des méthodes abstraites et des interfaces, pas même deux accolades ! ! ! Par exemple : function getName(); Cela fera l'affaire

2. Interface

En utilisant l'interface (interface), vous pouvez spécifier quelles méthodes une certaine classe doit implémenter, mais il n'est pas nécessaire de définir les spécificités 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 l'interface doivent être publiques. C'est une caractéristique de l'interface.

Implémentations

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.

Remarque :
Lors de l'implémentation de plusieurs interfaces, les méthodes des interfaces ne peuvent pas avoir le même nom.

Remarque :
Les interfaces peuvent également être héritées, en utilisant l'opérateur extends.

Remarque :
Pour implémenter une interface, une classe doit utiliser des méthodes qui sont exactement les mêmes que celles définies dans l'interface. Sinon, une erreur fatale en résultera.

Constantes

Des constantes peuvent également être définies dans l'interface. Les constantes d'interface sont utilisées exactement de la même manière que les constantes de classe, mais ne peuvent pas être remplacées par des sous-classes ou des sous-interfaces.

 <?php

// 声明一个&#39;iTemplate&#39;接口
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;
    }
}

// 下面的写法是错误的，会报错，因为没有实现 getHtml()：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
    private $vars = array();

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
}
?>
Example #2 可扩充的接口

<?php
interface a
{
    public function foo();
}

interface b extends a
{
    public function baz(Baz $baz);
}

// 正确写法
class c implements b
{
    public function foo()
    {
    }

    public function baz(Baz $baz)
    {
    }
}

// 错误写法会导致一个致命错误
class d implements b
{
    public function foo()
    {
    }

    public function baz(Foo $foo)
    {
    }
}
?>
Example #3 继承多个接口

<?php
interface a
{
    public function foo();
}

interface b
{
    public function bar();
}

interface c extends a, b
{
    public function baz();
}

class d implements c
{
    public function foo()
    {
    }

    public function bar()
    {
    }

    public function baz()
    {
    }
}
?>
Example #4 使用接口常量

<?php
interface a
{
    const b = &#39;Interface constant&#39;;
}

// 输出接口常量
echo a::b;

// 错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
class b implements a
{
    const b = &#39;Class constant&#39;;
}
?>

http://php.net/manual/zh/lingual.oop5.interfaces.php

Classe abstraite

PHP 5. Prend en charge les classes abstraites et les méthodes abstraites. Les classes définies comme abstraites ne peuvent pas être instanciées. Toute classe doit être déclarée abstraite si au moins une méthode qu'elle contient est déclarée abstraite. 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. Cela s'applique également aux constructeurs depuis PHP 5.4. Les déclarations des constructeurs avant PHP 5.4 pouvaient être différentes.

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . "\n";
    }
}

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_') ."\n";

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
?>
以上例程会输出：

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Example #2 抽象类示例

<?php
abstract class AbstractClass
{
    // 我们的抽象方法仅需要定义需要的参数
    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass
{

    // 我们的子类可以定义父类签名中不存在的可选参数
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>
以上例程会输出：

Mr. Pacman
Mrs. Pacwoman
老代码中如果没有自定义类或函数被命名为“abstract”，则应该能不加修改地正常运行。

http://php.net/manual/zh/lingual.oop5.abstract.php

Étude recommandée : "Tutoriel vidéo PHP"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!