Tutoriel PHP Basic 12 : Abstraction et interface

Contenu expliqué dans cette section

• Résumé

• Interface

• Utilisation des constantes de classe

• finales

Avant-propos

L'orientation objet en PHP consiste à instancier des objets en définissant des classes, et les classes abstraites et les classes d'interface de PHP peuvent être considérées comme une spécification de classes. Les classes sont définies en définissant ces deux contraintes obligatoires. sont des contraintes sur les classes, elles sont essentiellement différentes.

Classe abstraite

Nous pouvons utiliser la relation d'héritage des animaux pour illustrer le concept de classes abstraites Lorsque nous écrivons la classe parent Animal, il existe deux méthodes de sommeil. (), eat(), parce que je ne connais pas l'animal en question, je ne peux pas déterminer ce qui est écrit dans la méthode. Ceci peut être réalisé en utilisant des classes abstraites.

<?php
//通过关键字abstract来声明抽象类
abstract class Animal{
    protected $name;
    protected $age;
    //声明该方法是抽象方法
    abstract public function sleep();
    abstract public function eat();
}

Lorsque certaines méthodes de la classe parent ne peuvent pas être déterminées, le mot-clé abstract peut être utilisé pour modifier la méthode, qui est appelée méthode abstraite, et la classe modifiée avec abstract est appelée une classe abstraite.

Syntaxe de base :

abstract  class  类名{
    abstract  访问修饰符   函数名(参数列表);
}

Pendant le développement, lorsque nous voulons que toutes les sous-classes qui héritent de cette classe remplacent les méthodes de cette classe, nous pouvons utiliser des méthodes abstraites pour y parvenir. Une classe abstraite est comme une étagère pour quelque chose ou un modèle. Avec un modèle, vous pouvez implémenter des fonctions spécifiques basées sur le modèle. , et la relation entre les modèles et des éléments spécifiques est transmise via des classes héritées. Tout comme un ordinateur, les ordinateurs sont créés à partir de modèles. Les classes abstraites sont définies et doivent être héritées.

<?php

abstract class Animal{
    protected $name;
    protected $age;

    abstract public function sleep();
    abstract public function eat();
}
class Dog extends Animal{

}
......结果........
Fatal error: Class Dog contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (Animal::sleep, Animal::eat) 
in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\chouxiang.php on line 13

Lorsqu'une classe hérite d'une classe abstraite, toutes les méthodes abstraites de la classe parent doivent être implémentées dans la sous-classe L'erreur signalée ci-dessus signifie que la classe parent contient 2 méthodes abstraites , les sous-classes doivent implémenter cette méthode abstraite. Les caractéristiques des classes abstraites peuvent être résumées comme suit :

• Les classes abstraites ne peuvent pas être instanciées. Si vous ne pouvez pas créer un nouvel objet via une classe abstraite, une erreur Impossible d'instancier une classe abstraite sera signalée. .

• Il peut n'y avoir aucune méthode abstraite dans les classes abstraites. Toutes les méthodes des classes abstraites sont des méthodes ordinaires, mais le nom de la classe est modifié avec abstract.

  <?php
  abstract class Animal{
      protected $name;
      protected $age;
      public function sleep(){
  
      }
      public function eat(){
  
      }
  }

• Les classes abstraites peuvent avoir des méthodes membres ordinaires, des propriétés, etc.

  <?php
  abstract class Animal{
      protected $name;
      protected $age;
  
      abstract public function sleep();
      abstract public function eat();
  
      public function cry(){
  
      }
  }

• S'il y a des méthodes abstraites dans une classe , alors Cette classe doit être une classe abstraite.

• Les méthodes abstraites n'ont pas de corps de méthode

  abstract public function eat();

  Il n'y a pas de {}, ce qui signifie qu'il n'y a pas de corps de méthode.

• Si une classe hérite d'une classe abstraite, la sous-classe doit implémenter toutes les méthodes abstraites de la classe abstraite, ou la sous-classe elle-même doit être déclarée comme classe abstraite

Interface

L'intention originale de l'interface est la même que celle de la classe abstraite. Lorsque vous ne savez pas comment implémenter la méthode, vous pouvez utiliser l'interface pour. mettre en œuvre. La définition de l'interface est la suivante : donner quelques méthodes non implémentées, les encapsuler ensemble, puis écrire ces méthodes en fonction de la situation spécifique lorsqu'une certaine classe est utilisée. L'émergence des interfaces reflète les caractéristiques d'une cohésion élevée et d'un faible couplage.

<?php

interface iTechnical{
    public function fly();
}

Syntaxe de base :

interface 接口名{
    //方法, 在接口中，所有的方法都不能有方法体, 即都是抽象方法
}

Les classes d'interface sont à peu près les mêmes que les classes abstraites, alors qu'est-ce qu'une interface exactement ? Il est mentionné ci-dessus que les classes abstraites sont comme les étagères et les modèles d'un ordinateur portable, puis des ordinateurs portables spécifiques sont créés sur la base des modèles. Aucun ordinateur portable n'a plusieurs interfaces USB, et la classe d'interface est comme l'interface de ces ordinateurs portables, qui est une. mise en œuvre étendue. Tout comme les animaux, ils héritent des caractéristiques uniques des animaux, comme manger, dormir, etc., mais soudain, un animal réalise la capacité d'écrire ailleurs, et cette capacité est étendue grâce aux interfaces.

La dénomination des interfaces commence généralement par un i minuscule comme première lettre du nom de la classe. Toutes les méthodes de la classe d'interface sont des méthodes abstraites par défaut. Il n'est donc pas nécessaire d'écrire un résumé pour déclarer.

Implémentation de l'interface

Bien sûr, lorsque nous définissons une interface, nous laissons d'autres classes l'implémenter. Ce dont nous parlons ici, c'est d'implémentation, pas d'héritage, d'interfaces et. d'autres classes. Il existe une relation d'implémentation entre elles, c'est-à-dire que la classe implémente une certaine interface et est implémentée à l'aide du mot-clé Implements.

interface iTechnical{
    public function fly();
}

class Dog implements iTechnical{
    public function fly(){
        echo &#39;<br>飞&#39;;
    }
}

Bien sûr, toutes les méthodes de l'interface doivent être implémentées dans la sous-classe.

Les caractéristiques des interfaces sont les suivantes :

• Les classes d'interface, comme les classes abstraites, ne peuvent pas être instanciées.

• Toutes les méthodes de l'interface ne peuvent pas avoir de corps car ce sont toutes des méthodes abstraites.

• Une classe peut implémenter plusieurs interfaces, séparées par des virgules (l'héritage ne peut être qu'un seul)

  class Dog implements 接口1,接口2{
  
  }

• Les interfaces peuvent avoir des attributs, mais il ne peut s'agir que d'une constante. La valeur par défaut est publique, mais elle ne peut pas être explicitement modifiée avec public

• Les méthodes de l'interface doivent être publiques L'interface est destinée à l'héritage, utilisez donc public. . Si aucun modificateur n'est écrit, la valeur par défaut est public

• Une interface ne peut pas hériter d'autres classes, mais elle peut hériter d'autres interfaces

<🎜. > La différence entre abstraction et interface

L'héritage en PHP est un héritage unique, c'est-à-dire qu'une classe ne peut avoir qu'une seule classe parent au maximum. Ce mécanisme d'héritage unique peut garantir la pureté de la classe. Cependant, ce mécanisme a un certain impact sur l'expansion des fonctions des sous-classes.

接口的出现可以说是对继承的一种补充，继承是层级的，不太灵活，而接口却没有它比抽象要灵活的多。并且实现接口在不打破继承关系的前提下，对子类的功能进行扩充。
它们两个的关系图可以理解为这样：

final的使用

在上面的介绍中每个类都是可以被继承的，如果我们有一个类，我们不想让子类去重写里面的某个方法，或者不想让别的类去继承该类，就可以用到关键字final。final中文意思:最后的,最终的，可以用来修饰类或者方法。

final可以修饰方法或者类，如果修饰方法，则表示该方法不可以被继承类去重写，如果final 修饰了一个类，则表示该类不可以被继承。

基本语法：

final  class   类名{
}
class 类名{
    final 访问修饰符 function 函数名(形参){}
}

修饰类和修饰方法。

<?php

    final class A{

    }

    class B extends A{

    }
    .....结果.....
    Class B may not inherit from final class (A)

不能继承用final修饰的类。

<?php

    class A{
        final public function sum($num1,$num2){
            return $num1 + $num2;
        }

    }

    class B extends A{
        public function sum($num1,$num2){
            return $num1 + $num2;
        }
    }
    .....结果.....
    Cannot override final method A::sum()

从结果中可以看出来不能重写用final定义的方法。

在使用final时，只能用来修饰类或者方法，不能修饰属性。当一个类被final修饰后，类中的方法就不需要被final修饰，因为类都不能继承了，方法就不能重写。同时final修饰的类是可以被实例化的。

如果一个方法被final修饰，是可以被继承的，但是不能被重写。

<?php

    class A{
        final public function sum($num1,$num2){
            return $num1 + $num2;
        }

    }

    class B extends A{

    }

    $b = new B();
    echo $b -> sum(1,2);
    .......结果.......
    3

在我们写单例模式时，说过当时的单例模式是不完善的，可以通过继承来得到不同的对象，在这里我们使用final关键字修饰单例类，防止继承，这样就不能通过继承的到别的对象。

类常量

类常量和普通的常量是一个概念，当不希望一个成员变量被修改，希望该变量的值是固定不变的。这时可以用const去修饰该成员变量，这样这个变量就自动成为常量。在类中的常量称为类常量。前面我们讲过定义常量有两种方式define()和关键字const，在类中必须使用const这种方式，使用define()是会报错的。

<?php

    class A{
        const PI = 3.1415926;

        public function getPI(){
            return A::PI;
        }
    }

    $a = new A();
    echo $a -> getPI();
    echo &#39;<br>&#39;;
    echo A::PI;
    ......结果......
    3.1415926
    3.1415926

类常量的命名一般是全部用大写字母，中间用下划线隔开，同时常量前面没有$符号。常量必须在定义的时候就赋值。同时常量的前面不能有修饰符，默认是public。

常量的访问形式

常量的访问形式分为两种，一种是在类的内部进行访问，一种是在类的外部进行访问。

内部访问

通过 类名::常量名进行访问。

class A{
    const PI = 3.1415926;

    public function getPI(){
        return A::PI;//通过类名进行访问
    }
}

通过 self::常量名进行访问

class A{
    const PI = 3.1415926;

    public function getPI(){
        return self::PI;//通过类名进行访问
    }
}

可以通过self进行访问说明常量是属于类的，并不属于对象的。

外部访问

通过类名::常量名访问。

echo A::PI;

通过对象名::常量名访问

$a = new A();
echo $a::PI;

不过推荐使用第一种，通过类名进行访问。

如果一个类中有常量，则在继承的时候常量也是可以被继承的。同时常量的数据类型不能是对象。

总结

PHP中抽象和接口应用让我们的更加清楚的把握需求的骨架，更好的搭建我们的代码体系。同时利用抽象和接口降低代码的耦合度。利于代码的扩展。

 以上就是PHP基础教程十二之抽象、接口的内容，更多相关内容请关注PHP中文网（www.php.cn）！