Czym jest przeciążanie i nadpisywanie funkcji w php?

Przeciążenie funkcji występuje, gdy zdefiniujesz tę samą nazwę funkcji dwa razy (lub więcej) przy użyciu innego zestawu parametrów. Na przykład:

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

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

W powyższym przykładzie funkcja compute jest przeciążona dwoma różnymi sygnaturami parametrów. * To nie jest jeszcze obsługiwane w PHP. Alternatywą jest użycie opcjonalnych argumentów:

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

Nadpisywanie funkcji występuje, gdy rozszerzasz klasę i przepisujesz funkcję istniejącą w klasie nadrzędnej:

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

Na przykład, compute nadpisuje zachowanie określone w Addition.

Ściśle mówiąc, nie ma różnicy, bo Ty też nie możesz:)

Funkcja nadpisywania mogła być wykonana z rozszerzeniem PHP, takim jak APD, ale jest przestarzała, a ostatnia wersja afaik była bezużyteczna.

Przeciążenie funkcji w PHP nie może być wykonane z powodu dynamicznego pisania, tzn. w PHP nie" definiujemy " zmiennych jako konkretnego typu. Przykład:

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

Każda zmienna jest innego typu, ale możesz znać typ przed wykonaniem (Zobacz 4.). Jako porównanie, użycie innych języków:

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

W ostatnim przykładzie musisz ustawić typ zmiennej (jako przykład użyłem typu danych "coś").

Kolejny "problem", dlaczego przeciążenie funkcji nie jest możliwe w PHP: PHP posiada funkcję o nazwie func_get_args (), która zwraca tablicę bieżących argumentów, rozważ teraz następujący kod:

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

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

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

Biorąc pod uwagę obie funkcje akceptują dowolną ilość argumentów, które należy wybrać?

Na koniec chciałbym zwrócić uwagę, dlaczego powyższe odpowiedzi są częściowo błędne; funkcja przeciążenie/nadpisywanie nie jest równa metodzie przeciążenie/nadpisywanie.

Gdzie metoda jest podobna do funkcji, ale specyficzna dla klasy, w takim przypadku PHP pozwala na nadpisywanie klas, ale ponownie nie przeciąża, ze względu na semantykę języka.

Podsumowując, języki takie jak Javascript pozwalają na nadpisywanie (ale znowu, bez przeciążania), jednak mogą również pokazuje różnicę między nadpisywaniem funkcji użytkownika a metodą:

/// 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'

Przykład Przeciążenia

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);

Chociaż paradygmat przeciążenia nie jest w pełni wspierany przez PHP, ten sam (lub bardzo podobny) efekt można osiągnąć przy domyślnych parametrach (jak ktoś wspomniał wcześniej).

Jeśli zdefiniujesz swoją funkcję w ten sposób:

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

Gdy wywołujesz tę funkcję w następujący sposób:

f();

Otrzymasz jedną funkcjonalność (#1), ale jeśli wywołasz ją z parametrem takim jak:

f(1);

Otrzymasz kolejną funkcjonalność (#2). To efekt przeciążenia-różne funkcjonalności w zależności od parametr (- y) wejściowy (- e) funkcji.

Wiem, ktoś zapyta teraz, jaką funkcjonalność otrzyma, jeśli wywoła tę funkcję jako f (0).

Chciałbym tutaj zaznaczyć, że przeciążenie w PHP ma zupełnie inne znaczenie niż w innych językach programowania. Wiele osób powiedziało, że przeciążenie nie jest obsługiwane w PHP i przez konwencjonalną definicję przeciążenia, tak, że funkcjonalność nie jest jawnie dostępna.

Jednak prawidłowa definicja przeciążenia w PHP jest zupełnie inna.

W PHP przeciążenie odnosi się do dynamicznego tworzenia właściwości i metod wykorzystujących magiczne metody, takie jak _ _ set () I _ _ get (). Te metody przeciążania są wywoływane podczas interakcji z metodami lub właściwościami, które nie są dostępne lub nie są zadeklarowane.

Oto link z podręcznika PHP: http://www.php.net/manual/en/language.oop5.overloading.php

Istnieją pewne różnice między funkcjami przeciążającymi i nadpisującymi, choć obie zawierają tę samą funkcję name.In przeciążenie, między tymi samymi nazwami funkcje zawierają inny typ argumentu lub typ zwracanego; np.: "function add(int a,int b)" & "function add (float a, float b); Tutaj funkcja add() jest przeciążona. W przypadku nadpisania zarówno argument jak i nazwa funkcji są same.It zazwyczaj występuje w dziedziczeniu lub w cechach.Musimy przestrzegać pewnych taktyk, aby wprowadzić, jaka funkcja będzie teraz wykonywana. Tak więc w nadpisaniu programista postępuje zgodnie z pewną taktyką, aby wykonać żądaną funkcję, gdzie w przeciążeniu program może automatycznie zidentyfikować żądaną funkcję...Dzięki!

Przeciążenie: w prawdziwym świecie przeciążenie oznacza przypisanie komuś dodatkowych rzeczy. Tak jak w realnym świecie przeciążenie w PHP oznacza wywołanie dodatkowych funkcji. W inny sposób można powiedzieć, że ma szczuplejszą funkcję z różnymi parameter.In PHP można użyć przeciążenia za pomocą magicznych funkcji np. _ _ get, _ _ set, _ _ call itp.

Przykład przeciążenia:

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

Overriding: w programowaniu obiektowym overriding polega na zastąpieniu metody rodzica w potomku class.In nadpisywanie możesz ponownie zadeklarować metodę klasy rodzica w klasie potomnej. Tak więc, zasadniczo celem nadrzędnym jest zmiana zachowania metody klasowej rodzica.

Przykład przesłaniania:

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.x. x nie obsługuje przeciążania, dlatego PHP nie jest w pełni OOP.