Sovraccarico in PHP - Tipi e concetto di sovraccarico in PHP

• Che cos'è il sovraccarico in PHP?

Che cos'è il sovraccarico in PHP?

Abbiamo diversi concetti di programmazione orientata agli oggetti come classe, oggetto, incapsulamento, polimorfismo ecc. In PHP. Il sovraccarico è anche un tale concetto di OOP in PHP.

Il sovraccarico delle funzioni o il sovraccarico dei metodi è una funzione che consente di creare diversi metodi con lo stesso nome che differiscono tra loro nel tipo di parametri di input. È semplicemente definito come la capacità di una funzione di svolgere compiti diversi.

Definizione di sovraccarico in una riga: "stesso nome ma implementazioni diverse"

Come funziona il sovraccarico in PHP?

Come sappiamo, il sovraccarico del metodo viene eseguito sulle funzioni. Pertanto, le funzioni possono essere sovraccaricate con implementazioni diverse in base agli argomenti passati a ciascuna funzione. Ad esempio, per trovare l'area di un cerchio che è pi * r * r viene fornito il raggio, per trovare l'area del quadrato che è laterale * laterale, a condizione che sia data la lunghezza del lato, l'area di un triangolo è (base * altezza) / 2 a condizione che sia data la lunghezza e l'altezza e così via.

Il concetto di sovraccarico richiede metodi magici.

Magic Methods inizia con __ (doppio trattino basso) e viene chiamato automaticamente da PHP. Inoltre, questi sono sempre definiti all'interno della classe e non al di fuori della classe. Diversi metodi magici sono __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

Il sovraccarico quando eseguito crea dinamicamente proprietà e metodi che vengono chiamati insieme entità.

Le entità sono anche chiamate come

• proprietà: membri dei dati
• metodi: funzioni di dati

Vediamo come funziona il metodo magico usando il metodo __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);
?>


Nell'esempio sopra, abbiamo dichiarato una classe chiamata Test che ha proprietà private e un metodo __call. Due argomenti vengono passati al metodo __call. All'interno del metodo __call, abbiamo usato l'istruzione print (), a var_dump vengono restituiti gli argomenti e viene restituito un valore x.
Quindi viene creato l'oggetto della classe con il nome obj e usando questo oggetto viene chiamato un metodo indefinito poiché questo metodo non esiste __call () viene invece chiamato.
Tipi di sovraccarico in PHP
Esistono due tipi di sovraccarico in PHP e impariamo ogni tipo in dettaglio.

Sovraccarico di proprietà
Sovraccarico del metodo

1) Sovraccarico della proprietà
Il sovraccarico delle proprietà crea proprietà dinamiche quando l'oggetto è impostato. Questa proprietà è associata all'istanza della classe e se questa proprietà non è dichiarata nell'ambito della classe, viene considerata come proprietà sovraccaricata. Per questo, non è necessario scrivere alcun codice aggiuntivo. I seguenti metodi magici ci dicono di più sulla stessa cosa.
Di seguito sono indicate le operazioni eseguite con proprietà sovraccaricate
Proprietà sovraccariche di Setter e Getter (utilizzando __set () e __get ())
Valutazione dell'impostazione delle proprietà sovraccariche (utilizzando __isset ())
Annulla tale impostazione delle proprietà (usando __unset ())
Cerchiamo di capire l'uso di ciascuno di questi metodi
__set () => viene utilizzato per inizializzare le proprietà sovraccaricate.
__get () => viene utilizzato per recuperare le proprietà già inizializzate
__isset () => viene utilizzato per verificare se la proprietà è impostata o meno
__unset () => è usato per disinserire la proprietà.
__call () => viene utilizzato per inizializzare i metodi sovraccarichi
__callStatic () => viene utilizzato per inizializzare i metodi statici
Tutti i metodi sopra indicati sono utilizzati nell'esempio seguente.
Codice:
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;
Codice:

Produzione

2) Metodo di sovraccarico
Come il sovraccarico della proprietà, il sovraccarico del metodo crea un metodo dinamico dichiarato al di fuori dell'estensione della classe. E questo è possibile con i metodi magici __call () e __callStatic (). Questi vengono utilizzati in base rispettivamente al riferimento oggetto e al riferimento statico.
__call () -> viene utilizzato per chiamare metodi sovraccarichi nel riferimento all'oggetto
__callStatic () -> è usato per chiamare metodi sovraccarichi in riferimento statico
L'esempio seguente ti aiuterà a saperne di più.
<_?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();
?>
Codice:

Produzione:

Regole
1) L'identificatore di accesso pubblico viene utilizzato per i metodi di sovraccarico.
2) Viene utilizzato il processo di sovraccarico in cui è possibile accedere alle proprietà o ai metodi non definiti nell'ambito della classe, al momento della creazione dell'oggetto della classe.
3) I metodi magici sono usati per sovraccaricare proprietà o metodi. Dei due metodi magici utilizzati per i metodi di sovraccarico, il metodo più utilizzato è il metodo __call () nel contesto dell'oggetto e meno utilizzato è il metodo __callStatic () che viene utilizzato nel contesto statico.
Articolo raccomandato
Questa è una guida al sovraccarico in PHP. Qui discutiamo i tipi e il concetto di sovraccarico in PHP con gli esempi. Puoi anche leggere il seguente articolo per saperne di più -

Che cos'è PHP?
Cos'è l'array PHP?
Domande chiave per l'intervista a PHP
Funzioni stringa PHP
Sovraccarico in C # | Come funziona?
Introduzione al sovraccarico in C ++
Metodo statico in PHP
Sovraccarico e override in C #
Metodo Python Magic | Metodi, componenti (esempi)