Zwei Implementierungen von Polymorphismus in PHP: Überladen und Überschreiben

In diesem Artikel werden hauptsächlich die beiden Implementierungen von Polymorphismus in PHP vorgestellt: Überladen und Überschreiben. Ich hoffe, dass er für alle hilfreich ist. 2

Was ist Polymorphismus?

Polymorphismus bedeutet wörtlich „mehrere Zustände“. In objektorientierten Sprachen werden mehrere unterschiedliche Implementierungen einer Schnittstelle als Polymorphismus bezeichnet. Zitat von Charlie Calverts‘ Beschreibung des Polymorphismus: Polymorphismus ist eine Technik, die es Ihnen ermöglicht, ein übergeordnetes Objekt einem oder mehreren seiner untergeordneten Objekte gleichzusetzen. Nach der Zuweisung kann das übergeordnete Objekt seinen untergeordneten Objekten basierend auf dem aktuellen Wert zugewiesen werden . Funktionen funktionieren auf unterschiedliche Weise (aus „Insider Delphi 4 Programming Technology“). Einfach ausgedrückt ist es ein Satz: Es ist erlaubt, einen Zeiger eines Unterklassentyps einem Zeiger eines übergeordneten Klassentyps zuzuweisen (ja, diese Passage stammt aus der Baidu-Enzyklopädie). Welche Rolle spielt der Polymorphismus und welchen tatsächlichen Entwicklungswert hat er? In der tatsächlichen Anwendungsentwicklung besteht der Hauptzweck der Verwendung von objektorientiertem Polymorphismus darin, dass verschiedene Unterklassenobjekte als eine übergeordnete Klasse behandelt werden können und die Unterschiede zwischen verschiedenen Unterklassenobjekten abgeschirmt und universeller Objektcode geschrieben werden können, wodurch eine allgemeine Programmierung ermöglicht wird sich an veränderte Bedürfnisse anpassen.

Das Folgende sind zwei Implementierungen von Polymorphismus in PHP

Methodenüberladung (Überladung)

Überladen ist eine Implementierung des Klassenpolymorphismus. Funktionsüberladung bedeutet, dass ein Bezeichner als mehrfacher Funktionsname verwendet wird und diese Funktionen mit demselben Namen anhand der Nummer oder des Parametertyps der Funktion unterschieden werden können, sodass beim Aufruf keine Verwirrung entsteht. Das heißt, beim Aufruf sind die Methodennamen zwar gleich, die entsprechenden Funktionen können jedoch automatisch entsprechend unterschiedlichen Parametern aufgerufen werden.

class A{
  public function test(){
    echo "test1";
  }
  public function test($a){
    echo "test2";
  }
}
$a=new A();
$a->test();
$a->test($a);

Wenn PHP das Überladen von Methoden direkt unterstützt. Nachdem das obige Beispiel ausgeführt wurde, werden unterschiedliche Werte zurückgegeben, wenn Parameter übergeben werden und wenn Parameter nicht übergeben werden. Allerdings unterstützt PHP das Überladen nicht direkt, was bedeutet, dass ein Fehler gemeldet wird, wenn Sie es wie oben direkt definieren. Welcher Fehler wird gemeldet? Der folgende Fehler wird gemeldet.

Das bedeutet, dass Funktion A nicht wiederholt definiert werden kann und die Anzahl der Zeilen, die den Fehler melden, genau der folgenden Zeile entspricht.

public function test($a){

PHP unterstützt das Neuladen also nicht direkt. Der Co-Autor sagt seit langem, dass PHP dies nicht unterstützt. . Keine Sorge, ich habe gesagt, dass es nicht direkt unterstützt wird, also können wir PHP es indirekt unterstützen lassen. Zu diesem Zeitpunkt wird eine Funktion zur Unterstützung der Überlastung verwendet. Es ist __call(). Die Methode __call() muss zwei Parameter annehmen. Der erste Parameter enthält den Namen der aufgerufenen Methode, während der zweite Parameter das an die Methode übergebene Parameterarray enthält. Mit dieser Methode können Funktionen erreicht werden, die der Funktionsüberladung ähneln. Schauen Sie sich den Code unten an.

public function __call($method,$p)
{
  if($method=="display"){
    if(is_object($p[0])){
      $this->displayObject($p[0]);
    }else if(is_array($p[0])){
      $this->displayArray($p[0]);
    }else{
      $this->displayScalar($p[0]);
    }
  }
}
//下面是对上面定义的调用
$ov=new overload;
$ov->display(array(1,2,3));
$ov->display('cat');

Beim Definieren einer Methode können Sie sehen, dass es drei Zweige gibt. Wenn ein Objekt an die Methode display() übergeben wird, wird die Methode displayObject() aufgerufen, wenn ein Array übergeben wird, displayArray(). wird aufgerufen; Wenn andere Inhalte übergeben werden, wird die Methode displayScalar() aufgerufen. . . Sie können sehen, dass beim Aufruf unten zunächst ein Array übergeben wird und dann displayArray() aufgerufen wird. Das zweite übergebene Objekt ist weder ein Objekt noch ein Array, es gehört zu einem anderen Inhalt und die Methode displayScalar() wird aufgerufen. Auf diese Weise wird die Methode __call() verwendet, um eine Methodenüberladung ähnlich wie in anderen Sprachen zu implementieren.

Methodenüberschreibung (Override)

Die sogenannte Überschreibung ist im Wesentlichen ein Umschreiben. Das heißt, wenn eine Unterklasse einige Methoden von der übergeordneten Klasse erbt und die Unterklasse intern dieselbe Methode definiert, überschreibt die neu definierte Methode die von der übergeordneten Klasse geerbte Methode und die Unterklasse kann nur ihre intern definierten Methoden aufrufen.

hat die folgenden Anforderungen:

1 Wenn eine übergeordnete Klasse und eine Unterklasse eine Methode haben und die Parameter und Namen genau übereinstimmen Gleiches gilt, dann überschreiben Unterklassenmethoden die Methoden der übergeordneten Klasse.

2. Bei der Implementierung der Methodenabdeckung können die Zugriffsmodifikatoren unterschiedlich sein, der Zugriffsbereich der Unterklasse muss jedoch größer oder gleich dem Zugriffsbereich der übergeordneten Klasse sein.

3. Die Parameter müssen mit dem Namen übereinstimmen. Es ist nicht erforderlich, dass die Unterklasse denselben Namen wie die übergeordnete Klasse hat.

Im Folgenden finden Sie eine Erläuterung dieser Punkte:

Der erste Punkt ist, dass die Parameter konsistent sein müssen, um eine Methodenabdeckung zu erreichen. Wenn die Anzahl der Parameter inkonsistent ist, wird ein Fehler gemeldet (dies führt zu einer Überlastung der oben genannten Methoden). Wenn die Methodennamen inkonsistent sind, werden sie nicht überschrieben, sondern nur die neu definierten Methoden der Unterklasse. ;

Zweiter Punkt, das ist wahrscheinlich die Designregel von Sprachen wie PHP. Ich verstehe, dass es einfacher ist, auf Dinge auf höherer Ebene zuzugreifen. Wenn Sie auf Dinge auf niedrigerer Ebene zugreifen möchten, müssen Sie über höhere Berechtigungen verfügen.

Sehen Sie sich den Code an:

class people{
  protected function sing(){
    echo "人唱歌";
  }
} 
class woman extends people{
  public function sing(){
    echo "女人唱歌";
  }
}
$woman1=new woman();
$woman1->sing();

Dies ist eine normale Ausgabe für „Frauen singen“. Wenn jedoch die Methode sing () in woman in proctcted und das übergeordnete Element in public () geändert wird, dh nachdem die Zugriffsberechtigung der übergeordneten Klasse größer als die der Unterklasse festgelegt wurde, wird der folgende Fehler angezeigt gemeldet werden.

第三点，是要求参数和名字一样，具体就是要求参数的个数与父类相同，而并不是参数名称一致。即传递的参数名字可以为任意，只要保证传递的个数相同即可。

以上内容简单介绍了PHP语言中多态的两个实现。

PS：重写、覆盖、重载、多态几个概念的区别分析

override->重写(=覆盖)、overload->重载、polymorphism -> 多态

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：

1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
3、重写的方法的返回值必须和被重写的方法的返回一致；
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。

重载的规则：

1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。

一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

举个例子：

public class Shape 
{
  public static void main(String[] args){
   Triangle tri = new Triangle();
   System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
   Shape shape = new Triangle();
   System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
   Rectangle Rec = new Rectangle();
   Shape shape2 = Rec;
   System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
  }
  public boolean isShape(){
   return true;
  }
  public int getSides(){
   return 0 ;
  }
  public int getSides(Triangle tri){ //重载
   return 3 ;
  }
  public int getSides(Rectangle rec){ //重载
  return 4 ;
  }
}
class Triangle extends Shape 
{
  public int getSides() { //重写,实现多态
   return 3;
  }
}
class Rectangle extends Shape 
{
  public int getSides(int i) { //重载
  return i;
  }
}

总结：以上就是本篇文的全部内容，希望能对大家的学习有所帮助。

相关推荐：

PHP实现导出带样式的Excel实例分享

php解决和避免form表单重复提交的方法

PHP简单字符串过滤方法实例分享

Das obige ist der detaillierte Inhalt vonZwei Implementierungen von Polymorphismus in PHP: Überladen und Überschreiben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!