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

Respostas:

192

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"
?>
Jacob Relkin
fonte
31
O PHP não suporta sobrecarga, no entanto.
Sasha Chedygov
18
Sim, usando __call.
Jacob Relkin
50
O PHP substitui a sobrecarga por parâmetros opcionais.
b01
3
Obrigado pela idéia de parâmetros opcionais, é uma dica muito útil
Fabricio PH
2
__call () é acionado quando métodos inacessíveis são chamados no contexto de objetos __callStatic () método mímico é acionado quando métodos inacessíveis são chamados no contexto estático. Siga este para obter um exemplo mais detalhado e explicação de sobrecarga no contexto PHP: PHP Sobrecarga
Código Buster
107

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.

Andrew Moore
fonte
9
Exceto sobrecarga de função não é suportada no PHP, AFAIK. Além disso, como uma observação lateral não relacionada, não sei por que uma Subtractionclasse estenderia a Additionclasse. :)
Sasha Chedygov
6
@musicfreak: 12:40, horário local ... Não foi possível pensar em um exemplo melhor.
Andrew Moore
5
Isso ainda não é suportado no PHP e provavelmente nunca será, pois o PHP é uma linguagem de tipo fraco e nada vai mudar nesse caso.
Crozin 31/08/10
2
A sobrecarga não ocorre apenas quando você define o mesmo nome da função duas vezes (ou mais vezes) usando um conjunto diferente de parâmetros. Geralmente, a sobrecarga também ocorre quando você define o mesmo nome da função duas vezes (ou mais vezes) usando o mesmo número de parâmetros, mas de tipos diferentes. Como no PHP não há declaração de tipo variável (como em Java), essa generalização não importa. Estou apenas mencionando isso por uma questão de precisão, o que é sobrecarregar.
Sbrbot
2
@sbrbot: Set implica número e tipos.
Andrew Moore
22

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'
cristão
fonte
2
O PHP 5.xx não suporta sobrecarga, é por isso que o PHP não é totalmente OOP.
PHP Ferrari
30
Não é que o PHP não suporte sobrecarga, é que não pode fazer sentido. O problema ocorre devido ao PHP usar tipos dinâmicos. De fato, o Javascript também não suporta sobrecarga e ainda é OOP. O "PHP não é totalmente OOP" existe apenas porque algumas pessoas decidiram usar uma lista de verificação para julgar o que é OOP ou não.
Christian
@ ringø Não, as funções nomeadas no PHP são imutáveis. Depois de criar uma função nomeada no PHP, não há como você modificar seu comportamento interno (substituindo). A menos que você quisesse substituir o método, o que é outra coisa. Você provavelmente deve ler a resposta inteira antes de comentar na primeira linha. :)
Christian
@ Christian Bem, é claro que a substituição do PHP (e de muitas outras linguagens) ocorre em uma classe . Então, sim, estamos falando de métodos - mesmo que cada um deles seja prefixado com a função de palavra-chave . Mas na verdade eu deveria ter lido a resposta completa em primeiro lugar ...
e2-e4
9

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);
Caminhar
fonte
Implementação personalizada legal, mas deve ser fornecida pelo idioma.
4EACH
Este não é o método, sobrecarga de funções, enquanto você estiver usando outro nome de método para cada puporse
TomSawyer
5

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

sbrbot
fonte
1

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

Ram Iyer
fonte
1

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.

Shriyash Deshmukh
fonte
0

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!

Mashuq Tanmoy
fonte
0

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
user3040433
fonte
-14

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

PHP Ferrari
fonte
18
Não sei de onde você tirou a ideia de sobrecarregar um requisito para Programação Orientada a Objetos.
drewish
6
@ drewish porque o polimorfismo paramétrico é uma das características mais importantes da OOP?
Davor
1
@ drewish se você contar o polimorfismo como uma das principais estagnações da OOP. Então, sobrecarregar ostensivamente está lá fora para a compilação. No entanto, a sobrecarga de método é o polimorfismo em tempo de compilação e também conhecido como polimorfismo estático.
Yasir Arefin