PHP Basic Tutorial 12: Abstraktion und Schnittstelle

Inhalt in diesem Abschnitt erklärt

• Zusammenfassung

• Schnittstelle

• Verwendung von final

• Klassenkonstanten

Vorwort

Objektorientiert ist in PHP die Instanziierung von Objekten durch die Definition von Klassen, und die abstrakten Klassen und Schnittstellenklassen von PHP können als Spezifikation von Klassen bezeichnet werden, obwohl beides obligatorische Einschränkungen sind sind Einschränkungen für Klassen, sie unterscheiden sich grundsätzlich.

Abstrakte Klasse

Wir können die Vererbungsbeziehung von Tieren verwenden, um das Konzept der abstrakten Klasse zu veranschaulichen. Wenn wir die übergeordnete Klasse Animal schreiben, gibt es zwei Schlafmethoden (), eat(), da ich das spezifische Tier nicht kenne, kann ich nicht bestimmen, was in der Methode geschrieben ist. Dies kann mithilfe abstrakter Klassen erreicht werden.

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

Wenn einige Methoden der übergeordneten Klasse nicht bestimmt werden können, kann das Schlüsselwort abstract zum Ändern der Methode verwendet werden, die als abstrakte Methode bezeichnet wird, und die mit abstract geänderte Klasse wird als abstrakte Klasse bezeichnet.

Grundlegende Syntax:

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

Wenn wir während der Entwicklung möchten, dass alle Unterklassen, die diese Klasse erben, die Methoden dieser Klasse überschreiben, können wir abstrakte Methoden verwenden, um dies zu erreichen. Eine abstrakte Klasse ist wie ein Regal für etwas oder eine Vorlage. Mit einer Vorlage können Sie bestimmte Funktionen basierend auf der Vorlage implementieren. und die Beziehung zwischen Vorlagen und bestimmten Dingen wird über geerbte Klassen weitergegeben. Genau wie ein Computer werden Computer durch Vorlagen erstellt. Abstrakte Klassen sind definiert und müssen vererbt werden.

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

Wenn eine Klasse eine abstrakte Klasse erbt, müssen alle abstrakten Methoden der übergeordneten Klasse in der Unterklasse implementiert werden. Der oben gemeldete Fehler bedeutet, dass die übergeordnete Klasse zwei abstrakte Methoden enthält , Unterklassen müssen diese abstrakte Methode implementieren. Die Merkmale abstrakter Klassen können wie folgt zusammengefasst werden:

• Abstrakte Klassen können nicht instanziiert werden. Wenn Sie kein neues Objekt über eine abstrakte Klasse erstellen können, wird ein Fehler gemeldet, der die abstrakte Klasse nicht instanziieren kann .

• In abstrakten Klassen gibt es möglicherweise keine abstrakten Methoden. Alle Methoden in abstrakten Klassen sind gewöhnliche Methoden, aber der Klassenname wird durch abstrakt geändert.

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

• Abstrakte Klassen können gewöhnliche Mitgliedsmethoden, Eigenschaften usw. haben.

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

• Wenn eine Klasse abstrakte Methoden enthält , dann muss diese Klasse eine abstrakte Klasse sein.

• Abstrakte Methoden haben keinen Methodenkörper

  abstract public function eat();

  Es gibt kein {}, was bedeutet, dass es keinen Methodenkörper gibt.

• Wenn eine Klasse eine abstrakte Klasse erbt, muss die Unterklasse alle abstrakten Methoden der abstrakten Klasse implementieren oder die Unterklasse selbst muss als abstrakte Klasse deklariert werden

Schnittstelle

Die ursprüngliche Absicht der Schnittstelle ist dieselbe wie die der abstrakten Klasse. Wenn Sie nicht wissen, wie Sie die Methode implementieren, können Sie die Schnittstelle verwenden es umsetzen. Die Definition einer Schnittstelle lautet: Geben Sie einige nicht implementierte Methoden an, kapseln Sie sie zusammen und schreiben Sie diese Methoden dann entsprechend der spezifischen Situation, in der eine bestimmte Klasse verwendet wird. Die Entstehung von Schnittstellen spiegelt die Merkmale hoher Kohäsion und geringer Kopplung wider.

<?php

interface iTechnical{
    public function fly();
}

Grundlegende Syntax:

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

Schnittstellenklassen sind in etwa dasselbe wie abstrakte Klassen. Was genau ist also eine Schnittstelle? Oben wurde erwähnt, dass abstrakte Klassen wie die Regale und Vorlagen eines Notebooks sind und dann spezifische Notebooks basierend auf den Vorlagen erstellt werden. Kein Notebook verfügt über mehrere USB-Schnittstellen, und die Schnittstellenklasse ist wie die Schnittstelle auf diesen Notebooks erweiterte Umsetzung. Genau wie Tiere erben sie die einzigartigen Eigenschaften von Tieren wie Essen, Schlafen usw., aber plötzlich erkennt ein Tier die Fähigkeit, an anderer Stelle zu schreiben, und diese Fähigkeit wird durch Schnittstellen erweitert.

Die Benennung von Schnittstellen beginnt im Allgemeinen mit einem kleinen i als erstem Buchstaben des Klassennamens. Alle Methoden in der Schnittstellenklasse sind standardmäßig abstrakte Methoden. Es ist also nicht erforderlich, eine Zusammenfassung zu verfassen, um sie zu deklarieren.

Implementierung der Schnittstelle

Wenn wir eine Schnittstelle definieren, lassen wir sie natürlich von anderen Klassen implementieren. Hier geht es um Implementierung, nicht um Vererbung, Schnittstellen usw Zwischen anderen Klassen besteht eine Implementierungsbeziehung, das heißt, die Klasse implementiert eine bestimmte Schnittstelle und wird mithilfe des Schlüsselworts „implementiert“ implementiert.

interface iTechnical{
    public function fly();
}

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

Natürlich müssen alle Methoden in der Schnittstelle in der Unterklasse implementiert werden.

Die Eigenschaften von Schnittstellen sind wie folgt:

• Schnittstellenklassen können wie abstrakte Klassen nicht instanziiert werden.

• Alle Methoden in der Schnittstelle können keinen Körper haben, da es sich bei allen um abstrakte Methoden handelt.

• Eine Klasse kann mehrere durch Kommas getrennte Schnittstellen implementieren (Vererbung kann nur eine sein)

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

• Schnittstellen können Attribute haben, aber Es kann nur eine Konstante sein, aber es kann nicht explizit mit public geändert werden. Alle Methoden in der Schnittstelle müssen öffentlich sein, also verwenden public. Wenn kein Modifikator geschrieben ist, ist der Standardwert public

• Eine Schnittstelle kann keine anderen Klassen erben, aber sie kann andere Schnittstellen erben

• Der Unterschied zwischen Abstraktion und Schnittstelle

Vererbung in PHP ist Einzelvererbung, das heißt, eine Klasse kann höchstens eine übergeordnete Klasse haben. Dieser einzelne Vererbungsmechanismus kann die Reinheit der Klasse sicherstellen. Dieser Mechanismus hat jedoch einen gewissen Einfluss auf die Funktionserweiterung von Unterklassen.

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

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）！