Túlterhelés a PHP-ben A túlterhelés típusai és fogalma a PHP-ben

Tartalomjegyzék:

Anonim

Mi a túlterhelés a PHP-ben?

Az objektum-orientált programozás különböző fogalmakkal rendelkezik, mint például osztály, objektum, beágyazás, polimorfizmus stb. A PHP-ben. A túlterhelés az OOP-k ilyen fogalma a PHP-ben.

A funkció túlterhelése vagy a módszer túlterhelése olyan szolgáltatás, amely lehetővé teszi több azonos nevű módszer létrehozását, amelyek különböznek egymástól a bemeneti paraméterek típusában. Egyszerűen úgy definiálják, hogy egy funkció képes különféle feladatok elvégzésére.

A túlterhelés meghatározása egy sorban: „azonos név, de különböző megvalósítások”

Hogyan működik a túlterhelés a PHP-ben?

Mint tudjuk, a módszer túlterhelését a függvényeken hajtjuk végre. Így a funkciók túlterhelhetők különböző implementációkkal, az egyes függvényekhez átadott argumentumok alapján. Például egy kör * területének megkereséséhez, amely megadva a sugarat, ha pi * r * r van, hogy megtalálja a négyzet területét, amely oldal * oldal, ha megadjuk az oldal hosszát, egy háromszög területe (alap * magasság) / 2, feltéve, hogy megadjuk az alaphosszot és a magasságot, és így tovább.

A túlterhelési koncepció mágikus módszereket igényel.

A Magic Methods __-val kezdődik (dupla aláhúzás), és a PHP automatikusan meghívja. Ezeket is mindig az osztályon belül definiálják, és nem az osztályon kívül. Különböző varázslatos módszerek: __get (), __set, __ build (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

A túlterhelés végrehajtásakor tulajdonságokat és módszereket hoz létre dinamikusan, amelyeket együttesen entitásoknak hívnak.

Az entitásokat más néven

  • tulajdonságok: adat tagok
  • módszerek: adatfüggvények

Nézzük meg, hogy a mágikus módszer hogyan működik az __call () módszerrel

<_?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);
?>




A fenti példában bejelentettük a Test nevû osztályt, amely magántulajdonnal és __hívó módszerrel rendelkezik. Két érvet továbbítunk a __call módszerhez. Az __call metóduson belül a print print () utasítást használtuk, a var_dump argumentumok és az x érték visszaadásra kerülnek.




Ezután létrejön az obj névvel rendelkező objektum, és ezt az objektumot használva egy meghatározatlan módszert hívunk, mivel ez a módszer nem létezik, helyette az __call () hívja.


A PHP túlterhelésének típusai


Kétféle típusú túlterhelés létezik a PHP-ben, és tanulmányozzuk mindegyik típust részletesen.


    

  • Ingatlan túlterhelés
    • 

  • Módszer túlterhelés
    • 



1) Ingatlan túlterhelés


A tulajdonság túlterhelése dinamikus tulajdonságokat hoz létre, amikor az objektum be van állítva. Ez a tulajdonság az osztálypéldányhoz van társítva, és ha ezt a tulajdonságot nem jelentették be az osztály hatókörén belül, akkor azt túlterhelt tulajdonságnak kell tekinteni. Ehhez nem kell extra kódot írni. A következő varázslatos módszerek ugyanazról szólnak.


Az alábbiakban megemlítjük a túlterhelt tulajdonságokkal végzett műveleteket



A Setter és a Getter túlterhelt tulajdonságai (a __set () és __get () használatával)


A túlterhelt tulajdonságok beállításának értékelése (a __isset () használatával)


Visszavonja az ilyen tulajdonságok beállítását (a __unset () használatával)


Megértjük ezen módszerek mindegyikét


Az __set () => a túlterhelt tulajdonságok inicializálására szolgál.


Az __get () => a már inicializált tulajdonságok beolvasására szolgál




Az __isset () => ellenőrzi, hogy a tulajdonság be van-e állítva


Az __unset () => a tulajdonság szétválasztására szolgál.


Az __call () => a túlterhelt módszerek inicializálására szolgál


Az __callStatic () => a statikus módszerek inicializálására szolgál


Az összes fenti módszert együtt alkalmazzuk a következő példában.


Kód:


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;





Kód:




Kimenet




2) Módszertúlterhelés


Az ingatlan-túlterheléshez hasonlóan a módszer-túlterhelés dinamikus módszert hoz létre, amelyet az osztály hatókörén kívül deklarálnak. És ez lehetséges __call () és __callStatic () mágikus módszerekkel. Ezeket az objektumreferencia és a statikus referencia alapján használják.


Az __call () -> az objektumreferencia túlterhelt módszereinek hívására szolgál


Az __callStatic () -> statikus hivatkozásban a túlterhelt módszerek hívására szolgál


A következő példa segít többet megtudni.


<_?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();
?>


Kód:




Kimenet:




szabályok


1) A nyilvános hozzáférés-specifikátort használják a túlterhelési módszerekhez.


2) A túlterhelési folyamatot akkor alkalmazzák, ahol az osztály területén belül nem meghatározott tulajdonságok vagy módszerek érhetők el, az osztály objektumának létrehozásakor.


3) A mágikus módszereket használják a tulajdonságok vagy módszerek túlterhelésére. A túlterheléshez használt két mágikus módszer közül a leggyakrabban használt módszer az __call () metódus objektumkörnyezetben, a kevésbé használt __callStatic () módszer, amelyet statikus kontextusban használnak.



Ajánlott cikk


Ez egy útmutató a PHP túlterheléséhez. Itt a példákkal tárgyaljuk a PHP túlterhelésének típusait és fogalmát. A következő cikkben további információkat is megnézhet -


    

  1. Mi a PHP?
    2. 

  2. Mi a PHP tömb?
    3. 

  3. Alapvető PHP interjúkérdések
    4. 

  4. PHP karakterlánc funkciók
    5. 

  5. Túlterhelés a C # | -ben Hogyan működik?
    6. 

  6. Bevezetés a túlterheléshez a C ++ kategóriában
    7. 

  7. Statikus módszer a PHP-ben
    8. 

  8. Túlterhelés és felülbírálás a C # -ben
    9. 

  9. Python mágikus módszer | Módszerek, alkatrészek (példák)
    10.