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

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

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 -

Mi a PHP?
Mi a PHP tömb?
Alapvető PHP interjúkérdések
PHP karakterlánc funkciók
Túlterhelés a C # | -ben Hogyan működik?
Bevezetés a túlterheléshez a C ++ kategóriában
Statikus módszer a PHP-ben
Túlterhelés és felülbírálás a C # -ben
Python mágikus módszer | Módszerek, alkatrészek (példák)