Vad är överbelastning i PHP?

Vi har olika begrepp om objektorienterad programmering som klass, objekt, kapsling, polymorfism etc i PHP. Överbelastning är också ett sådant begrepp för OOP i PHP.

Funktionsöverbelastning eller metodöverbelastning är en funktion som gör det möjligt att skapa flera metoder med samma namn som skiljer sig från varandra i typen av inmatningsparametrar. Det definieras helt enkelt som en funktions förmåga att utföra olika uppgifter.

Definition av överbelastning i en rad: "samma namn men olika implementationer"

Hur fungerar överbelastning i PHP?

Som vi vet utförs metodöverbelastning på funktioner. Således kan funktioner överbelastas med olika implementationer baserat på argumenten som skickas till varje funktion. Till exempel för att hitta området för en cirkel som är pi * r * r förutsatt att radien ges, för att hitta kvadratområdet som är sida * sida, förutsatt att längden på sidan anges är arean av en triangel (bas * höjd) / 2 förutsatt att baslängden och höjden anges och så vidare.

Överbelastningskoncept kräver magiska metoder.

Magiska metoder börjar med __ (dubbel understreck) och kallas automatiskt av PHP. Även dessa definieras alltid inom klassen och inte utanför klassen. Olika magiska metoder är __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

Överbelastning när den utförs skapar egenskaper och metoder dynamiskt som tillsammans kallas enheterna.

Enheterna kallas också som

  • egenskaper: data medlemmar
  • metoder: datafunktioner

Låt oss titta på hur den magiska metoden fungerar med metoden __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);
?>

I exemplet ovan har vi förklarat en klass som heter Test som har privat egendom och en __callmetod. Två argument överförs till __call-metoden. Inuti __call-metoden har vi använt utskriftstryck (), en var_dump argumenten och ett värde x returneras.

Sedan skapas objektet för klassen med namnet obj och med detta objekt kallas en odefinierad metod eftersom den här metoden inte finns __call () kallas istället.

Typer av överbelastning i PHP

Det finns två typer av överbelastning i PHP och låt oss lära oss varje typ i detalj.

  • Fastighetsöverbelastning
  • Metod överbelastning

1) Fastighetsöverbelastning

Fastighetsöverbelastning skapar dynamiska egenskaper när objektet är inställt. Den här egenskapen är kopplad till klassinstansen, och om den här egenskapen inte deklareras inom klassens omfattning, betraktas den som överbelastad egendom. För detta behöver du inte skriva någon extra kod. Följande magiska metoder berättar mer om samma sak.

Nedan nämns operationer som utförs med överbelastade egenskaper

Setter och Getter överbelastade egenskaper (med __set () och __get ())

Utvärdera inställningen för överbelastade egenskaper (med __isset ())

Ångra sådana egenskaper (med __unset ())

Låt oss förstå användningen av var och en av dessa metoder

__set () => används för att initialisera överbelastade egenskaper.

__get () => används för att hämta de redan initierade egenskaperna

__isset () => används för att kontrollera om fastigheten är inställd eller inte

__unset () => används för att avaktivera egenskapen.

__call () => används för att initiera överbelastade metoder

__callStatic () => används för att initiera statiska metoder

Alla ovanstående metoder tillsammans används i följande exempel.

Koda:

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;

Koda:

Produktion

2) Metodöverbelastning

Liksom överbelastning av fastigheter skapar metodöverbelastning en dynamisk metod som förklaras utanför klassens omfattning. Och detta är möjligt med __call () och __callStatic () magiska metoder. Dessa används baserat på objektreferensen respektive den statiska referensen.

__call () -> används för att ringa överbelastade metoder i objektreferensen

__callStatic () -> används för att ringa överbelastade metoder i statisk referens

Följande exempel hjälper dig att lära dig mer.

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

Koda:

Produktion:

regler

1) Specifikationen för allmän åtkomst används för överbelastningsmetoderna.

2) Överbelastningsprocessen används där de egenskaper eller metoder som inte definieras inom klassens omfattning kan nås vid skapandet av klassens objekt.

3) Magiska metoder används för överbelastning av egenskaper eller metoder. Av de två magiska metoderna som används för överbelastningsmetoder är den mest använda metoden __call () -metoden i objektsammanhang och mindre används är __callStatic () -metoden som används i statisk sammanhang.

Rekommenderad artikel

Detta är en guide till överbelastning i PHP. Här diskuterar vi typerna och begreppet överbelastning i PHP med exemplen. Du kan också titta på följande artikel för att lära dig mer -

  1. Vad är PHP?
  2. Vad är PHP Array?
  3. Core PHP intervjufrågor
  4. PHP-strängfunktioner
  5. Överbelastning i C # | Hur det fungerar?
  6. Introduktion till överbelastning i C ++
  7. Statisk metod i PHP
  8. Överbelastning och överbestyrning i C #
  9. Python Magic Method | Metoder, komponenter (exempel)

Kategori: