O que é função sobrecarregando e substituindo em php?

Em PHP, o que você quer dizer com sobrecarga de função e substituição de função. e qual é a diferença entre os dois? não conseguia descobrir qual é a diferença entre eles.

Sobrecarregar é definir funções que possuem assinaturas semelhantes, mas têm parâmetros diferentes. A substituição é pertinente apenas às classes derivadas, onde a classe pai definiu um método e a classe derivada deseja substituir esse método.

No PHP, você só pode sobrecarregar métodos usando o método mágico __call .

Um exemplo de substituição :

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

A sobrecarga de função ocorre quando você define o mesmo nome da função duas vezes (ou mais) usando um conjunto diferente de parâmetros. Por exemplo:

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

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

No exemplo acima, a função computeestá sobrecarregada com duas assinaturas de parâmetros diferentes. * Isso ainda não é suportado em PHP. Uma alternativa é usar argumentos opcionais:

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

A substituição da função ocorre quando você estende uma classe e reescreve uma função que existia na classe pai:

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

Por exemplo, computesubstitui o comportamento estabelecido em Addition.

A rigor, não há diferença, pois você também não pode fazer isso :)

A substituição de função poderia ter sido feita com uma extensão PHP como APD, mas está obsoleta e a última versão era inutilizável.

A sobrecarga de função no PHP não pode ser feita devido à digitação dinâmica, ou seja, no PHP você não "define" variáveis ​​para um tipo específico. Exemplo:

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

Cada variável é de um tipo diferente, mas você pode conhecer o tipo antes da execução (consulte a quarta). Como comparação, outros idiomas usam:

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

No último exemplo, você deve definir com força o tipo da variável (como exemplo, usei o tipo de dados "something").

Outro "problema" por que a sobrecarga de funções não é possível no PHP: o PHP tem uma função chamada func_get_args (), que retorna uma matriz de argumentos atuais, agora considere o seguinte 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 as funções aceitam qualquer quantidade de argumentos, qual deles o compilador deve escolher?

Por fim, gostaria de salientar por que as respostas acima estão parcialmente erradas; a sobrecarga / substituição da função NÃO é igual à sobrecarga / substituição do método .

Onde um método é como uma função, mas específico para uma classe, nesse caso, o PHP permite substituir nas classes, mas novamente nenhuma sobrecarga, devido à semântica da linguagem.

Para concluir, idiomas como Javascript permitem a substituição (mas, novamente, sem sobrecarga), no entanto, eles também podem mostrar a diferença entre substituir uma função do usuário e um 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'

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

Embora o paradigma de sobrecarga não seja totalmente suportado pelo PHP, o mesmo efeito (ou muito semelhante) pode ser alcançado com o (s) parâmetro (s) padrão (s) (como alguém mencionado anteriormente).

Se você definir sua função assim:

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

Quando você chama essa função como:

f();

você obterá uma funcionalidade (nº 1), mas se a chamar com parâmetro como:

f(1);

você receberá outra funcionalidade (nº 2). Esse é o efeito da sobrecarga - funcionalidade diferente, dependendo do (s) parâmetro (s) de entrada da função.

Eu sei, alguém perguntará agora que funcionalidade obteremos se chamar essa função como f (0).

Gostaria de salientar aqui que a sobrecarga no PHP tem um significado completamente diferente em comparação com outras linguagens de programação. Muitas pessoas disseram que a sobrecarga não é suportada no PHP e pela definição convencional de sobrecarga, sim, a funcionalidade não está explicitamente disponível.

No entanto, a definição correta de sobrecarga no PHP é completamente diferente.

No PHP, sobrecarga refere-se à criação dinâmica de propriedades e métodos usando métodos mágicos como __set () e __get (). Esses métodos de sobrecarga são chamados ao interagir com métodos ou propriedades que não estão acessíveis ou não são declaradas.

Aqui está um link do manual do PHP: http://www.php.net/manual/en/language.oop5.overloading.php

A sobrecarga de método ocorre quando dois ou mais métodos com o mesmo nome de método, mas com um número diferente de parâmetros na classe única. O PHP não suporta sobrecarga de método. Substituição de método significa dois métodos com o mesmo nome de método e o mesmo número de parâmetros em duas classes diferentes significa classe pai e classe filho.

Existem algumas diferenças entre sobrecarga e substituição de função, embora ambas contenham o mesmo nome da função. Na sobrecarga, as funções com o mesmo nome contêm diferentes tipos de argumento ou tipo de retorno; como: "function add (int a, int b)" & " function add (float a, float b); Aqui a função add () está sobrecarregada. No caso de substituir o argumento e o nome da função, são os mesmos. Geralmente é encontrado em herança ou em traços. Temos que seguir algumas táticas para introduzir , que função será executada agora Então, ao substituir o programador, segue algumas táticas para executar a função desejada, onde na sobrecarga o programa pode identificar automaticamente a função desejada ... Obrigado!

Sobrecarga: no mundo real, sobrecarregar significa atribuir algumas coisas extras a alguém. Como no mundo real Sobrecarregar no PHP significa chamar funções extras. De outra maneira, você pode dizer que possui uma função mais fina com parâmetros diferentes. No PHP, você pode usar sobrecarga com funções mágicas, por exemplo, __get, __set, __call etc.

Exemplo 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

Substituindo: na programação orientada a objeto, substituir é substituir o método pai na classe filho. Na substituição, você pode declarar novamente o método da classe pai na classe filho. Portanto, basicamente o objetivo de substituir é alterar o comportamento do método da classe pai.

Exemplo de substituição:

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

O PHP 5.xx não suporta sobrecarga, é por isso que o PHP não é totalmente OOP.