¿Qué es la sobrecarga y anulación de funciones en php?

En PHP, ¿qué quiere decir con sobrecarga de funciones y anulación de funciones? y cual es la diferencia entre ambos? no podía entender cuál es la diferencia entre ellos.

La sobrecarga es definir funciones que tienen firmas similares, pero que tienen parámetros diferentes. La anulación solo es pertinente para las clases derivadas, donde la clase principal ha definido un método y la clase derivada desea anular ese método.

En PHP, solo puedes sobrecargar métodos usando el método mágico __call.

Un ejemplo de anulación :

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

La sobrecarga de funciones ocurre cuando define el mismo nombre de función dos veces (o más) usando un conjunto diferente de parámetros. Por ejemplo:

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

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

En el ejemplo anterior, la función computeestá sobrecargada con dos firmas de parámetros diferentes. * Esto aún no es compatible con PHP. Una alternativa es usar argumentos opcionales:

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

La anulación de funciones ocurre cuando extiende una clase y reescribe una función que existía en la clase primaria:

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

Por ejemplo, computeanula el comportamiento establecido en Addition.

Estrictamente hablando, no hay diferencia, ya que tampoco puedes hacerlo :)

La anulación de funciones podría haberse realizado con una extensión PHP como APD, pero está en desuso y la última versión de afaik no se podía usar.

La sobrecarga de funciones en PHP no se puede realizar debido a la tipificación dinámica, es decir, en PHP no "define" las variables para que sean de un tipo en particular. Ejemplo:

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

Cada variable es de un tipo diferente, sin embargo, puede conocer el tipo antes de la ejecución (consulte la cuarta). Como comparación, otros idiomas usan:

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

En el último ejemplo, debe establecer con fuerza el tipo de variable (como ejemplo, usé el tipo de datos "algo").

Otro "problema" por el que la sobrecarga de funciones no es posible en PHP: PHP tiene una función llamada func_get_args (), que devuelve una matriz de argumentos actuales, ahora considere el siguiente código:

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

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

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

Considerando que ambas funciones aceptan cualquier cantidad de argumentos, ¿cuál debería elegir el compilador?

Finalmente, me gustaría señalar por qué las respuestas anteriores son parcialmente incorrectas; la sobrecarga / anulación de la función NO es igual a la sobrecarga / anulación del método .

Cuando un método es como una función pero específico de una clase, en cuyo caso, PHP permite anular en las clases, pero nuevamente no sobrecargar, debido a la semántica del lenguaje.

Para concluir, los lenguajes como Javascript permiten anular (pero de nuevo, no sobrecargar), sin embargo, también pueden mostrar la diferencia entre anular una función de usuario y un método:

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

Ejemplo de sobrecarga

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

Aunque el paradigma de sobrecarga no es totalmente compatible con PHP, se puede lograr el mismo efecto (o muy similar) con los parámetros predeterminados (como alguien mencionó anteriormente).

Si define su función de esta manera:

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

Cuando llamas a esta función como:

f();

obtendrá una funcionalidad (# 1), pero si la llama con parámetros como:

f(1);

Obtendrá otra funcionalidad (# 2). Ese es el efecto de la sobrecarga: una funcionalidad diferente según los parámetros de entrada de la función.

Lo sé, alguien preguntará ahora qué funcionalidad obtendrá uno si llama a esta función como f (0).

Me gustaría señalar aquí que la sobrecarga en PHP tiene un significado completamente diferente en comparación con otros lenguajes de programación. Mucha gente ha dicho que la sobrecarga no es compatible con PHP y, según la definición convencional de sobrecarga, sí, esa funcionalidad no está explícitamente disponible.

Sin embargo, la definición correcta de sobrecarga en PHP es completamente diferente.

En PHP, la sobrecarga se refiere a la creación dinámica de propiedades y métodos utilizando métodos mágicos como __set () y __get (). Estos métodos de sobrecarga se invocan al interactuar con métodos o propiedades que no son accesibles o no se declaran.

Aquí hay un enlace del manual de PHP: http://www.php.net/manual/en/language.oop5.overloading.php

La sobrecarga de métodos ocurre cuando dos o más métodos con el mismo nombre de método pero diferente número de parámetros en una sola clase. PHP no admite la sobrecarga de métodos. La anulación de métodos significa dos métodos con el mismo nombre de método y el mismo número de parámetros en dos clases diferentes significa clase primaria y clase secundaria.

Hay algunas diferencias entre la sobrecarga y la anulación de funciones, aunque ambas contienen el mismo nombre de función. En sobrecarga, entre las mismas funciones de nombre contienen diferentes tipos de argumento o tipo de retorno; tales como: "function add (int a, int b)" & " función add (float a, float b); aquí la función add () está sobrecargada. En el caso de anular tanto el argumento como el nombre de la función son los mismos. Generalmente se encuentra en herencia o en rasgos. Tenemos que seguir algunas tácticas para introducir , qué función se ejecutará ahora. Entonces, al anular el programador, se siguen algunas tácticas para ejecutar la función deseada, donde en la sobrecarga el programa puede identificar automáticamente la función deseada ... ¡Gracias!

Sobrecarga: en el mundo real, la sobrecarga significa asignar algunas cosas adicionales a alguien. Como en el mundo real, la sobrecarga en PHP significa llamar a funciones adicionales. De otra manera, puede decir que tiene una función más delgada con diferentes parámetros. En PHP puede usar la sobrecarga con funciones mágicas, por ejemplo, __get, __set, __call, etc.

Ejemplo de sobrecarga:

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

Anulación: en la programación orientada a objetos, la anulación es reemplazar el método principal en la clase secundaria. En la anulación, puede volver a declarar el método de la clase primaria en la clase secundaria. Entonces, básicamente, el propósito de anular es cambiar el comportamiento de su método de clase padre.

Ejemplo de anulación:

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 no admite sobrecarga, por eso PHP no es completamente OOP.