Was ist Funktionsüberladung und -überschreibung in PHP?

Was verstehen Sie in PHP unter Funktionsüberladung und Funktionsüberschreibung? und was ist der Unterschied zwischen beiden? konnte nicht herausfinden, was der Unterschied zwischen ihnen ist.

Überladen definiert Funktionen mit ähnlichen Signaturen, jedoch unterschiedlichen Parametern. Das Überschreiben ist nur für abgeleitete Klassen relevant, bei denen die übergeordnete Klasse eine Methode definiert hat und die abgeleitete Klasse diese Methode überschreiben möchte .

In PHP können Sie Methoden nur mit der magischen Methode überladen __call.

Ein Beispiel für das Überschreiben :

<?php

class Foo {
   function myFoo() {
      return "Foo";
   }
}

class Bar extends Foo {
   function myFoo() {
      return "Bar";
   }
}

$foo = new Foo;
$bar = new Bar;
echo($foo->myFoo()); //"Foo"
echo($bar->myFoo()); //"Bar"
?>

Funktionsüberladung tritt auf, wenn Sie denselben Funktionsnamen zweimal (oder mehrmals) mit unterschiedlichen Parametersätzen definieren. Beispielsweise:

class Addition {
  function compute($first, $second) {
    return $first+$second;
  }

  function compute($first, $second, $third) {
    return $first+$second+$third;
  }
}

Im obigen Beispiel ist die Funktion computemit zwei verschiedenen Parametersignaturen überladen. * Dies wird in PHP noch nicht unterstützt. Eine Alternative besteht darin, optionale Argumente zu verwenden:

class Addition {
  function compute($first, $second, $third = 0) {
    return $first+$second+$third;
  }
}

Das Überschreiben von Funktionen tritt auf, wenn Sie eine Klasse erweitern und eine in der übergeordneten Klasse vorhandene Funktion neu schreiben:

class Substraction extends Addition {
  function compute($first, $second, $third = 0) {
    return $first-$second-$third;
  }
}

Zum Beispiel computeüberschreibt die eingestellte Verhalten nach Addition.

Genau genommen gibt es keinen Unterschied, da Sie das auch nicht können :)

Das Überschreiben von Funktionen hätte mit einer PHP-Erweiterung wie APD erfolgen können, ist jedoch veraltet und die letzte Version von afaik war unbrauchbar.

Funktionsüberladung in PHP kann aufgrund dynamischer Typisierung nicht durchgeführt werden, dh in PHP "definieren" Sie Variablen nicht als einen bestimmten Typ. Beispiel:

$a=1;
$a='1';
$a=true;
$a=doSomething();

Jede Variable hat einen anderen Typ, Sie können den Typ jedoch vor der Ausführung kennen (siehe den vierten). Zum Vergleich verwenden andere Sprachen:

int a=1;
String s="1";
bool a=true;
something a=doSomething();

Im letzten Beispiel müssen Sie den Variablentyp zwangsweise festlegen (als Beispiel habe ich den Datentyp "etwas" verwendet).

Ein weiteres "Problem", warum eine Funktionsüberladung in PHP nicht möglich ist: PHP hat eine Funktion namens func_get_args (), die ein Array aktueller Argumente zurückgibt. Betrachten Sie nun den folgenden Code:

function hello($a){
  print_r(func_get_args());
}

function hello($a,$a){
  print_r(func_get_args());
}

hello('a');
hello('a','b');

Wenn man bedenkt, dass beide Funktionen eine beliebige Anzahl von Argumenten akzeptieren, welches sollte der Compiler wählen?

Abschließend möchte ich darauf hinweisen, warum die obigen Antworten teilweise falsch sind; Das Überladen / Überschreiben von Funktionen entspricht NICHT dem Überladen / Überschreiben von Methoden .

Wenn eine Methode wie eine Funktion ist, aber für eine Klasse spezifisch ist, erlaubt PHP in diesem Fall das Überschreiben in Klassen, aber wiederum keine Überladung aufgrund der Sprachsemantik.

Zusammenfassend lässt sich sagen, dass Sprachen wie Javascript das Überschreiben (aber auch kein Überladen) zulassen. Sie können jedoch auch den Unterschied zwischen dem Überschreiben einer Benutzerfunktion und einer Methode aufzeigen:

/// Function Overriding ///

function a(){
   alert('a');
}
a=function(){
   alert('b');
}

a(); // shows popup with 'b'


/// Method Overriding ///

var a={
  "a":function(){
    alert('a');
  }
}
a.a=function(){
   alert('b');
}

a.a(); // shows popup with 'b'

Überladungsbeispiel

class overload {
    public $name;
    public function __construct($agr) {
        $this->name = $agr;
    }
    public function __call($methodname, $agrument) {
         if($methodname == 'sum2') {

          if(count($agrument) == 2) {
              $this->sum($agrument[0], $agrument[1]);
          }
          if(count($agrument) == 3) {

              echo $this->sum1($agrument[0], $agrument[1], $agrument[2]);
          }
        }
    }
    public function sum($a, $b) {
        return $a + $b;
    }
    public function sum1($a,$b,$c) {

        return $a + $b + $c;
    }
}
$object = new overload('Sum');
echo $object->sum2(1,2,3);

Obwohl das Überladungsparadigma von PHP nicht vollständig unterstützt wird, kann der gleiche (oder sehr ähnliche) Effekt mit Standardparametern erzielt werden (wie bereits erwähnt).

Wenn Sie Ihre Funktion folgendermaßen definieren:

function f($p=0)
{
  if($p)
  {
    //implement functionality #1 here
  }
  else
  {
    //implement functionality #2 here
  }
}

Wenn Sie diese Funktion wie folgt aufrufen:

f();

Sie erhalten eine Funktionalität (Nr. 1), aber wenn Sie sie mit folgenden Parametern aufrufen:

f(1);

Sie erhalten eine weitere Funktionalität (# 2). Das ist der Effekt der Überladung - unterschiedliche Funktionen abhängig von den Eingabeparametern der Funktion.

Ich weiß, jemand wird jetzt fragen, welche Funktionalität man bekommt, wenn er diese Funktion als f (0) aufruft.

Ich möchte hier darauf hinweisen, dass das Überladen in PHP im Vergleich zu anderen Programmiersprachen eine völlig andere Bedeutung hat. Viele Leute haben gesagt, dass Überladung in PHP nicht unterstützt wird und nach der herkömmlichen Definition von Überladung ja, dass Funktionalität nicht explizit verfügbar ist.

Die korrekte Definition der Überladung in PHP ist jedoch völlig anders.

In PHP bezieht sich Überladung auf das dynamische Erstellen von Eigenschaften und Methoden mit magischen Methoden wie __set () und __get (). Diese Überladungsmethoden werden aufgerufen, wenn mit Methoden oder Eigenschaften interagiert wird, auf die nicht zugegriffen werden kann oder die nicht deklariert sind.

Hier ist ein Link aus dem PHP-Handbuch: http://www.php.net/manual/en/language.oop5.overloading.php

Methodenüberladung tritt auf, wenn zwei oder mehr Methoden mit demselben Methodennamen, aber unterschiedlicher Anzahl von Parametern in einer Klasse. PHP unterstützt keine Methodenüberladung. Das Überschreiben von Methoden bedeutet, dass zwei Methoden mit demselben Methodennamen und derselben Anzahl von Parametern in zwei verschiedenen Klassen übergeordnete Klasse und untergeordnete Klasse bedeuten.

Es gibt einige Unterschiede zwischen Funktionsüberladung und -überschreibung, obwohl beide denselben Funktionsnamen enthalten. Beim Überladen enthalten Funktionen mit demselben Namen unterschiedliche Argument- oder Rückgabetypen. Beispiel: "function add (int a, int b)" & " Funktion add (float a, float b); Hier ist die Funktion add () überladen. Beim Überschreiben sind sowohl das Argument als auch der Funktionsname gleich. Sie findet sich im Allgemeinen in der Vererbung oder in Merkmalen. Wir müssen einige Taktiken befolgen, um sie einzuführen , welche Funktion wird jetzt ausgeführt? Beim Überschreiben folgt der Programmierer einigen Taktiken, um die gewünschte Funktion auszuführen, wobei das Programm beim Überladen automatisch die gewünschte Funktion identifizieren kann ... Danke!

Überladen: In der realen Welt bedeutet Überladen, jemandem zusätzliche Dinge zuzuweisen. Wie in der realen Welt bedeutet Überladen in PHP das Aufrufen zusätzlicher Funktionen. Auf andere Weise können Sie sagen, dass es eine schlankere Funktion mit verschiedenen Parametern hat. In PHP können Sie das Überladen mit magischen Funktionen verwenden, z. B. __get, __set, __call usw.

Beispiel für Überladung:

class Shape {
   const Pi = 3.142 ;  // constant value
  function __call($functionname, $argument){
    if($functionname == 'area')
    switch(count($argument)){
        case 0 : return 0 ;
        case 1 : return self::Pi * $argument[0] ; // 3.14 * 5
        case 2 : return $argument[0] * $argument[1];  // 5 * 10
    }

  }

 }
 $circle = new Shape();`enter code here`
 echo "Area of circle:".$circle->area()."</br>"; // display the area of circle Output 0
 echo "Area of circle:".$circle->area(5)."</br>"; // display the area of circle
 $rect = new Shape();
 echo "Area of rectangle:".$rect->area(5,10); // display area of rectangle

Überschreiben: Bei der objektorientierten Programmierung wird beim Überschreiben die übergeordnete Methode in der untergeordneten Klasse ersetzt. Beim Überschreiben können Sie die übergeordnete Klassenmethode in der untergeordneten Klasse erneut deklarieren. Der Zweck des Überschreibens besteht also im Wesentlichen darin, das Verhalten Ihrer übergeordneten Klassenmethode zu ändern.

Beispiel für das Überschreiben:

class parent_class
{

  public function text()    //text() is a parent class method
  {
    echo "Hello!! everyone I am parent class text method"."</br>";
  }
  public function test()   
  {
    echo "Hello!! I am second method of parent class"."</br>";
  }

}

class child extends parent_class
{
  public function text()     // Text() parent class method which is override by child 
  class
  {
    echo "Hello!! Everyone i am child class";
  }

 }

 $obj= new parent_class();
 $obj->text();            // display the parent class method echo
 $obj= new parent_class();
 $obj->test();
 $obj= new child();
 $obj->text(); // display the child class method echo

PHP 5.xx unterstützt keine Überladung. Aus diesem Grund ist PHP nicht vollständig OOP.