¿Qué es la sobrecarga y sobreescritura de funciones en php?

La sobrecarga de funciones se produce cuando se define el mismo nombre de función dos veces (o más) utilizando diferentes conjuntos 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 compute está sobrecargada con dos firmas de parámetros diferentes. * Esto aún no está soportado en PHP. Una alternativa es usar argumentos opcionales:

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

La sobreescritura de funciones se produce cuando se extiende una clase y se reescribe una función que existía en la clase padre:

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

Por ejemplo, compute anula el comportamiento establecido en Addition.

Estrictamente hablando, no hay diferencia, ya que no puedes hacer ninguna de las dos cosas:)

La sobreescritura de funciones podría haberse hecho con una extensión PHP como APD, pero está obsoleta y la última versión de afaik fue inutilizable.

La sobrecarga de funciones en PHP no se puede hacer debido a la tipificación dinámica, es decir, en PHP no "define" las variables como un tipo 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 4ª). Como comparación, uso de otros idiomas:

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

En el último ejemplo, debe establecer con fuerza el tipo de la 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 ambas funciones acepta cualquier cantidad de argumentos, cuál debería ser el compilador ¿elegir?

Finalmente, me gustaría señalar por qué las respuestas anteriores son parcialmente erróneas; function sobrecarga/primordial NO es igual a método sobrecarga/reemplazar.

Donde un método es como una función pero específico para una clase, en cuyo caso, PHP permite la sobreescritura en las clases, pero de nuevo no la sobrecarga, debido a la semántica del lenguaje.

Para concluir, lenguajes como Javascript permiten overriding (pero de nuevo, sin sobrecarga), sin embargo también pueden muestra la diferencia entre sobreescribir 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 está completamente soportado por PHP, el mismo (o muy similar) efecto se puede lograr con los parámetros predeterminados(como alguien mencionó antes).

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 un parámetro como:

f(1);

Obtendrá otra funcionalidad (#2). Ese es el efecto de la sobrecarga - diferentes funcionalidades dependiendo de parámetro(s) de entrada de la función.

Lo sé, alguien preguntará ahora qué funcionalidad obtendrá 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 está soportada en PHP y por la definición convencional de sobrecarga, sí que la 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 crear dinámicamente propiedades y métodos usando 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 están declarados.

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

Hay algunas diferencias entre la sobrecarga y sobreescritura de funciones, aunque ambas contienen la misma función name.In sobrecarga, entre el mismo nombre las funciones contienen diferente tipo de argumento o tipo de retorno;Tales como: "function add (int a, int b)" & " function add (float a, float b); Aquí la función add () está sobrecargada. En el caso de sobreescribir tanto el argumento como el nombre de la función son same.It generalmente se encuentra en herencia o en rasgos.Tenemos que seguir algunas tácticas para introducir, qué función se ejecutará ahora. Así que En sobreescribir el programador sigue algunas tácticas para ejecutar la función deseada donde en la sobrecarga el programa puede identificar automáticamente la función deseada...¡Gracias!

Sobrecargar: En el mundo real, sobrecargar significa asignar algunas cosas adicionales a alguien. Como en el mundo real Sobrecargar en PHP significa llamar a funciones adicionales. De otra manera Se puede decir que tiene función slimier con diferentes parameter.In PHP puede utilizar 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

Sobreescritura: En la programación orientada a objetos sobreescritura es reemplazar el método padre en el hijo class.In sobreescribiendo puede volver a declarar el método de la clase padre en la clase hija. Por lo tanto, básicamente el propósito de la sobreescritura es cambiar el comportamiento de su método de clase padre.

Ejemplo de sobreescritura:

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 no soporta sobrecarga esta es la razón por la que PHP no es completamente OOP.