O que é Sobrecarga em PHP?

Temos conceitos diferentes de programação orientada a objetos, como classe, objeto, encapsulamento, polimorfismo etc. no PHP. Sobrecarregar também é um conceito de OOPs em PHP.

Sobrecarga de função ou sobrecarga de método é um recurso que permite criar vários métodos com o mesmo nome que diferem entre si no tipo de parâmetros de entrada. É simplesmente definido como a capacidade de uma função executar tarefas diferentes.

Definição de sobrecarga em uma linha: “mesmo nome, mas implementações diferentes”

Como a sobrecarga funciona em PHP?

Como sabemos, a sobrecarga de método é realizada em funções. Assim, as funções podem ser sobrecarregadas com diferentes implementações com base nos argumentos passados ​​para cada função. Por exemplo, para encontrar a área de um círculo que é pi * r * r, desde que o raio seja dado, para encontrar a área do quadrado que é do lado * do lado, desde que o comprimento do lado seja dado, a área de um triângulo é (base * altura) / 2 desde que o comprimento e a altura da base sejam fornecidos e assim por diante.

O conceito de sobrecarga requer métodos mágicos.

Métodos mágicos começam com __ (sublinhado duplo) e são chamados automaticamente pelo PHP. Também são sempre definidos dentro da classe e não fora da classe. Diferentes métodos mágicos são __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

A sobrecarga quando executada cria propriedades e métodos dinamicamente que são chamados juntos de entidades.

As entidades também são chamadas como

  • propriedades: membros de dados
  • métodos: funções de dados

Vejamos como o método mágico funciona usando o método __call ()

<_?php
class Test(
private $a = array('one', 'two', 'three');
public function__call($method, $args) (
print "Method $method called:\n";
echo " ";
print_r($args);
return $this->a;
)
)
$obj = new Test();
$a = obj->anyMethod(1, 2, 3);
var_dump($a);
?>

 class Test(
private $a = array('one', 'two', 'three');
public function__call($method, $args) (
print "Method $method called:\n";
echo " ";
print_r($args);
return $this->a;
)
)
$obj = new Test();
$a = obj->anyMethod(1, 2, 3);
var_dump($a);
?>

No exemplo acima, declaramos uma classe chamada Test que possui propriedade privada e um método __call. Dois argumentos são passados ​​para o método __call. Dentro do método __call, usamos a instrução print (), um var_dump os argumentos e um valor x são retornados.

Em seguida, o objeto da classe com o nome obj é criado e, usando esse objeto, é chamado um método indefinido, já que esse método não existe. __Call () é chamado.

Tipos de sobrecarga no PHP

Existem dois tipos de sobrecarga no PHP e vamos aprender cada tipo em detalhes.

  • Sobrecarga de propriedade
  • Sobrecarga de método

1) Sobrecarga de propriedade

A sobrecarga de propriedades cria propriedades dinâmicas quando o objeto é definido. Essa propriedade está associada à instância da classe e, se essa propriedade não for declarada dentro da extensão da classe, ela será considerada propriedade sobrecarregada. Para isso, você não precisa escrever nenhum código extra. Os seguintes métodos mágicos nos dizem mais sobre o mesmo.

Abaixo mencionadas estão as operações executadas com propriedades sobrecarregadas

Propriedades sobrecarregadas do Setter e Getter (usando __set () e __get ())

Avaliando a configuração de propriedades sobrecarregadas (usando __isset ())

Desfazer a configuração dessas propriedades (usando __unset ())

Vamos entender o uso de cada um desses métodos

__set () => é usado para inicializar propriedades sobrecarregadas.

__get () => é usado para buscar as propriedades já inicializadas

__isset () => é usado para verificar se a propriedade está configurada ou não

__unset () => é usado para desmarcar a propriedade.

__call () => é usado para inicializar métodos sobrecarregados

__callStatic () => é usado para inicializar métodos estáticos

Todos os métodos acima juntos são usados ​​no exemplo a seguir.

Código:

class PropertyOverloading (
public $details = array();
//declaring private property
private $j=20;
// setter operation
public function __set($name, $value) (
echo "
". " In the Setting operation. Set '$name = $value'";
$this->details($name) = $value;
)
// getter operation
public function __get($name) (
echo "
". " In the Getting Operation. Get '$name = '";
return $this->details($name) . '
';
)
// isset operation
public function __isset($name) (
echo "
". " In the isset Operation. isset '$name' ?";
return isset($this->details($name));
)
// unset operation
public function __unset($name) (
echo "
". " In the unset Operation. unset '$name' ";
unset($this->details($name));
)
// returning private property value
public function getPrivateProperty() (
return "
". " j = ".$this->j;
)
)
// creating object of class PropertyOverloading
// setter and getter methods are called
$obj = new PropertyOverloading();
$obj->x = 10;
echo $obj->x;
//call isset method
var_dump(isset($obj->x));
//call unset method
unset($obj->x);
//check whether object x is unset or not
var_dump(isset($obj->x));
//getting method to access the private property
echo "
". $obj-> getPrivateProperty();
//calling directly the private property
// throws error
echo "
accessing the private property, throws error";
echo "
".$obj->j;

Código:

Resultado

2) Sobrecarga de método

Como a sobrecarga de propriedade, a sobrecarga de método cria um método dinâmico que é declarado fora da extensão da classe. E isso é possível com os métodos mágicos __call () e __callStatic (). Eles são usados ​​com base na referência do objeto e na referência estática, respectivamente.

__call () -> é usado para chamar métodos sobrecarregados na referência de objeto

__callStatic () -> é usado para chamar métodos sobrecarregados na referência estática

O exemplo a seguir ajudará você a aprender mais.

<_?php
class MethodOverloading
(
public function __call($name, $param)(
echo "--With object reference
";
)
public static function __callStatic($name, $param)(
echo "-----With static reference
";
)
)
// creating object of class MethodOverloading
$obj = new MethodOverloading;
echo "Method Overloading
";
// using the object reference
$obj->DemoTest();
// using the static reference
MethodOverloading::DemoTest();
?>

Código:

Resultado:

Regras

1) O especificador de acesso público é usado para os métodos de sobrecarga.

2) O processo de sobrecarga é usado no qual as propriedades ou métodos não definidos dentro da extensão da classe podem ser acessados ​​na criação do objeto da classe.

3) Métodos mágicos são usados ​​para sobrecarregar propriedades ou métodos. Dos dois métodos mágicos usados ​​para sobrecarregar os métodos, o método mais usado é o método __call () no contexto do objeto e menos usado é o método __callStatic (), usado no contexto estático.

Artigo recomendado

Este é um guia para sobrecarregar em PHP. Aqui discutimos os tipos e o conceito de sobrecarga no PHP com os exemplos. Você também pode consultar o seguinte artigo para saber mais -

  1. O que é PHP?
  2. O que é a matriz PHP?
  3. Perguntas básicas da entrevista do PHP
  4. Funções de String PHP
  5. Sobrecarga em c # | Como funciona?
  6. Introdução à sobrecarga em C ++
  7. Método estático em PHP
  8. Sobrecarregando e substituindo em c #
  9. Método mágico Python | Métodos, Componentes (Exemplos)