Supraîncărcarea în PHP - Tipuri și conceptul de supraîncărcare în PHP

• Ce este supraîncărcarea în PHP?

Ce este supraîncărcarea în PHP?

Avem concepte diferite de programare orientată pe obiecte, cum ar fi clasa, obiectul, încapsularea, polimorfismul etc, în PHP. Supraîncărcarea este, de asemenea, un astfel de concept de OOP în PHP.

Supraîncărcarea funcției sau supraîncărcarea metodei este o caracteristică care permite crearea mai multor metode cu același nume care diferă unele de altele în ceea ce privește tipul parametrilor de intrare. Este pur și simplu definit ca capacitatea unei funcții de a îndeplini sarcini diferite.

Definiția supraîncărcării într-o singură linie: „același nume, dar implementări diferite”

Cum funcționează supraîncărcarea în PHP?

După cum știm, supraîncărcarea metodei se efectuează pe funcții. Astfel, funcțiile pot fi supraîncărcate cu implementări diferite pe baza argumentelor transmise fiecărei funcții. De exemplu, pentru a găsi aria unui cerc care este pi * r * r cu condiția să fie dată raza, pentru a găsi aria pătratului care este latura * latură, cu condiția să se dea lungimea laturii, aria unui triunghi este (baza * înălțimea) / 2 cu condiția ca lungimea bazei și înălțimea să fie dată și așa mai departe.

Conceptul de supraîncărcare necesită metode Magic.

Metodele magice începe cu __ (subliniere dublă) și este apelat automat de PHP. De asemenea, acestea sunt definite întotdeauna în interiorul clasei și nu în afara clasei. Diferite metode magice sunt __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

Supraîncărcarea atunci când este executată creează în mod dinamic proprietăți și metode, care sunt numite împreună entități.

Entitățile sunt, de asemenea, numite ca

• proprietăți: membri de date
• metode: funcții de date

Să ne uităm la modul în care funcționează metoda magică folosind metoda __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);
?>


În exemplul de mai sus, am declarat o clasă numită Test care are proprietate privată și o metodă __call. Două argumente sunt transmise metodei __call. În cadrul metodei __call, am folosit instrucțiunea print (), o var_dump argumentele și o valoare x sunt returnate.
Apoi, obiectul clasei cu numele obj este creat și folosind acest obiect este apelată o metodă nedefinită, deoarece această metodă nu există __call () este numită în schimb.
Tipuri de supraîncărcare în PHP
Există două tipuri de supraîncărcare în PHP și permiteți-ne să învățăm fiecare tip în detaliu.

Supraîncărcarea proprietății
Metoda Suprasarcina

1) Supraîncărcarea proprietății
Supraîncărcarea proprietății creează proprietăți dinamice atunci când obiectul este setat. Această proprietate este asociată cu instanța de clasă și dacă această proprietate nu este declarată în limitele clasei, este considerată proprietate supraîncărcată. Pentru aceasta, nu trebuie să scrieți niciun cod suplimentar. Următoarele metode magice ne spun mai multe despre același lucru.
Mai jos menționate sunt operațiunile efectuate cu proprietăți supraîncărcate
Proprietăți supraîncărcate Setter și Getter (folosind __set () și __get ())
Evaluarea setării proprietăților supraîncărcate (folosind __isset ())
Anulați setarea de astfel de proprietăți (folosind __unset ())
Să înțelegem utilizarea fiecăreia dintre aceste metode
__set () => este utilizat pentru inițializarea proprietăților supraîncărcate.
__get () => este folosit pentru a obține proprietățile inițializate
__isset () => este utilizat pentru a verifica dacă proprietatea este setată sau nu
__unset () => este folosit pentru a deselecta proprietatea.
__call () => este utilizat pentru inițializarea metodelor supraîncărcate
__callStatic () => este utilizat pentru inițializarea metodelor statice
Toate metodele de mai sus sunt utilizate în următorul exemplu.
Cod:
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;
Cod:

producție

2) Suprasarcina metodei
Ca și supraîncărcarea proprietății, suprasarcina metodei creează o metodă dinamică care este declarată în afara domeniului clasei Și acest lucru este posibil cu metodele magice __call () și __callStatic (). Acestea sunt utilizate pe baza referinței obiectului, respectiv a referinței statice.
__call () -> este folosit pentru apelarea metodelor supraîncărcate în referința obiectului
__callStatic () -> este utilizat pentru apelarea metodelor supraîncărcate în referință statică
Următorul exemplu vă va ajuta să aflați mai multe.
<_?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();
?>
Cod:

ieşire:

reguli
1) Specificatorul de acces public este utilizat pentru metodele de supraîncărcare.
2) Procesul de supraîncărcare este utilizat în care proprietățile sau metodele care nu sunt definite în limitele clasei pot fi accesate, la crearea obiectului clasei.
3) Metodele magice sunt utilizate pentru supraîncărcarea proprietăților sau a metodelor. Dintre cele două metode magice utilizate pentru supraîncărcarea, cea mai folosită metodă este metoda __call () în contextul obiectului, iar cea mai puțin folosită este metoda __callStatic () care este folosită în contextul static.
Articol recomandat
Acesta este un ghid pentru supraîncărcare în PHP. Aici discutăm tipurile și conceptul de supraîncărcare în PHP cu exemple. De asemenea, puteți consulta articolul următor pentru a afla mai multe -

Ce este PHP?
Ce este PHP Array?
Întrebări principale pentru interviu PHP
Funcții cu șiruri PHP
Supraîncărcarea în C # | Cum functioneaza?
Introducere la supraîncărcare în C ++
Metoda statică în PHP
Supraîncărcare și suprasolicitare în C #
Metoda Magic Python | Metode, componente (exemple)