Sobrecarga en PHP - Tipos y el concepto de sobrecarga en PHP

• ¿Qué es la sobrecarga en PHP?

¿Qué es la sobrecarga en PHP?

Tenemos diferentes conceptos de programación orientada a objetos como clase, objeto, encapsulación, polimorfismo, etc. en PHP. La sobrecarga también es un concepto de OOP en PHP.

La sobrecarga de funciones o sobrecarga de métodos es una característica que permite crear varios métodos con el mismo nombre que difieren entre sí en el tipo de parámetros de entrada. Simplemente se define como la capacidad de una función para realizar diferentes tareas.

Definición de sobrecarga en una línea: "mismo nombre pero diferentes implementaciones"

¿Cómo funciona la sobrecarga en PHP?

Como sabemos, la sobrecarga de métodos se realiza en las funciones. Por lo tanto, las funciones se pueden sobrecargar con diferentes implementaciones basadas en los argumentos pasados ​​a cada función. Por ejemplo, para encontrar el área de un círculo que es pi * r * r siempre que se proporcione el radio, para encontrar el área del cuadrado que es lado * lado, siempre que se proporcione la longitud del lado, el área de un triángulo es (base * altura) / 2 siempre que se proporcione la longitud de la base y la altura, y así sucesivamente.

El concepto de sobrecarga requiere métodos mágicos.

Magic Methods comienza con __ (doble guión bajo) y PHP lo llama automáticamente. Además, estos siempre se definen dentro de la clase y no fuera de la clase. Los diferentes métodos mágicos son __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

La sobrecarga cuando se realiza crea propiedades y métodos dinámicamente, que juntos se denominan entidades.

Las entidades también se llaman como

• propiedades: miembros de datos
• métodos: funciones de datos

Veamos cómo funciona el método mágico usando el 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);
?>


En el ejemplo anterior, hemos declarado una clase llamada Test que tiene propiedad privada y un método __call. Se pasan dos argumentos al método __call. Dentro del método __call, hemos utilizado la instrucción print (), a var_dump se devuelven los argumentos y un valor x.
Luego se crea el objeto de la clase con el nombre obj y al usar este objeto se llama a un método indefinido ya que este método no existe __call () en su lugar.
Tipos de sobrecarga en PHP
Hay dos tipos de sobrecarga en PHP y aprendamos cada tipo en detalle.

Sobrecarga de propiedad
Método de sobrecarga

1) Sobrecarga de propiedad
La sobrecarga de propiedades crea propiedades dinámicas cuando se establece el objeto. Esta propiedad está asociada con la instancia de clase, y si esta propiedad no se declara dentro del alcance de la clase, se considera como una propiedad sobrecargada. Para esto, no necesita escribir ningún código adicional. Los siguientes métodos mágicos nos dicen más sobre lo mismo.
A continuación se mencionan las operaciones realizadas con propiedades sobrecargadas.
Propiedades sobrecargadas de Setter y Getter (usando __set () y __get ())
Evaluación de la configuración de propiedades sobrecargadas (usando __isset ())
Deshacer dicha configuración de propiedades (usando __unset ())
Comprendamos el uso de cada uno de estos métodos.
__set () => se usa para inicializar propiedades sobrecargadas.
__get () => se usa para recuperar las propiedades ya inicializadas
__isset () => se usa para verificar si la propiedad está configurada o no
__unset () => se usa para desarmar la propiedad.
__call () => se usa para inicializar métodos sobrecargados
__callStatic () => se usa para inicializar métodos estáticos
Todos los métodos anteriores juntos se usan en el siguiente ejemplo.
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:

Salida

2) Método de sobrecarga
Al igual que la sobrecarga de propiedades, la sobrecarga de métodos crea un método dinámico que se declara fuera del alcance de la clase. Y esto es posible con los métodos mágicos __call () y __callStatic (). Estos se utilizan en función de la referencia del objeto y la referencia estática respectivamente.
__call () -> se usa para llamar a métodos sobrecargados en la referencia de objeto
__callStatic () -> se usa para llamar a métodos sobrecargados en referencia estática
El siguiente ejemplo lo ayudará a aprender más.
<_?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:

Salida:

Reglas
1) El especificador de acceso público se utiliza para los métodos de sobrecarga.
2) El proceso de sobrecarga se utiliza en el que se puede acceder a las propiedades o métodos no definidos dentro del alcance de la clase, en la creación del objeto de la clase.
3) Los métodos mágicos se utilizan para sobrecargar propiedades o métodos. De los dos métodos mágicos utilizados para los métodos de sobrecarga, el método más utilizado es el método __call () en el contexto del objeto y menos utilizado es el método __callStatic () que se utiliza en el contexto estático.
Artículo recomendado
Esta es una guía de sobrecarga en PHP. Aquí discutimos los tipos y el concepto de sobrecarga en PHP con los ejemplos. También puede consultar el siguiente artículo para obtener más información:

¿Qué es PHP?
¿Qué es la matriz PHP?
Preguntas principales de la entrevista PHP
Funciones de cadena PHP
Sobrecarga en C # | ¿Cómo funciona?
Introducción a la sobrecarga en C ++
Método estático en PHP
Sobrecarga y anulación en C #
Método mágico de Python | Métodos, Componentes (Ejemplos)