Wat bedoel je in PHP met functieoverbelasting en functieoverschrijving. en wat is het verschil tussen beide? kon niet achterhalen wat het verschil tussen hen is.
Antwoord 1, autoriteit 100%
Overbelastingis het definiëren van functies met vergelijkbare handtekeningen, maar met verschillende parameters. Overschrijvenis alleen relevant voor afgeleide klassen, waarbij de bovenliggende klasse een methode heeft gedefinieerd en de afgeleide klasse die methode wil overschrijven.
In PHP kun je alleen methoden overbelasten met de magische methode __call.
Een voorbeeld van overschrijven:
<?php
class Foo {
function myFoo() {
return "Foo";
}
}
class Bar extends Foo {
function myFoo() {
return "Bar";
}
}
$foo = new Foo;
$bar = new Bar;
echo($foo->myFoo()); //"Foo"
echo($bar->myFoo()); //"Bar"
?>
Antwoord 2, autoriteit 57%
Overbelasting van functies treedt op wanneer u dezelfde functienaam twee keer (of meer) definieert met een andere set parameters. Bijvoorbeeld:
class Addition {
function compute($first, $second) {
return $first+$second;
}
function compute($first, $second, $third) {
return $first+$second+$third;
}
}
In het bovenstaande voorbeeld is de functie computeoverbelast met twee verschillende parameterhandtekeningen. *Dit wordt nog niet ondersteund in PHP. Een alternatief is om optionele argumenten te gebruiken:
class Addition {
function compute($first, $second, $third = 0) {
return $first+$second+$third;
}
}
Het overschrijven van functies vindt plaats wanneer u een klasse uitbreidt en een functie herschrijft die bestond in de bovenliggende klasse:
class Substraction extends Addition {
function compute($first, $second, $third = 0) {
return $first-$second-$third;
}
}
Bijvoorbeeld, computeheft het gedrag op dat is uiteengezet in Addition.
Antwoord 3, autoriteit 11%
Strict genomen is er geen verschil, aangezien u geen van beide kunt doen 🙂
Functie overschrijven had kunnen worden gedaan met een PHP-extensie zoals APD, maar het is verouderd en de laatste versie was onbruikbaar.
Overbelasting van functies in PHP kan niet worden gedaan vanwege dynamisch typen, dwz in PHP “definieert” u variabelen niet als een bepaald type. Voorbeeld:
$a=1;
$a='1';
$a=true;
$a=doSomething();
Elke variabele is van een ander type, maar u kunt het type kennen voordat u het uitvoert (zie de vierde).
Ter vergelijking gebruiken andere talen:
int a=1;
String s="1";
bool a=true;
something a=doSomething();
In het laatste voorbeeld moet je het type van de variabele met kracht instellen (ik heb bijvoorbeeld het gegevenstype “iets” gebruikt).
Een ander “probleem” waarom overbelasting van functies niet mogelijk is in PHP:
PHP heeft een functie genaamd func_get_args(), die een array van huidige argumenten retourneert, overweeg nu de volgende code:
function hello($a){
print_r(func_get_args());
}
function hello($a,$a){
print_r(func_get_args());
}
hello('a');
hello('a','b');
Aangezien beide functies een willekeurig aantal argumenten accepteren, welke moet de compiler dan kiezen?
Tot slot wil ik u erop wijzen waarom de bovenstaande antwoorden gedeeltelijk onjuist zijn;
functieoverbelasten/overschrijven is NIET gelijk aan methodeoverbelasten/overschrijven.
Waar een methode lijkt op een functie, maar specifiek is voor een klasse, in welk geval PHP overschrijven in klassen toestaat, maar wederom geen overbelasting, vanwege taalsemantiek.
Tot slot, talen zoals Javascript laten overschrijven toe (maar nogmaals, geen overbelasting), maar ze kunnen ook het verschil laten zien tussen het overschrijven van een gebruikersfunctie en een methode:
/// Function Overriding ///
function a(){
alert('a');
}
a=function(){
alert('b');
}
a(); // shows popup with 'b'
/// Method Overriding ///
var a={
"a":function(){
alert('a');
}
}
a.a=function(){
alert('b');
}
a.a(); // shows popup with 'b'
Antwoord 4, autoriteit 5%
Overbelastingsvoorbeeld
class overload {
public $name;
public function __construct($agr) {
$this->name = $agr;
}
public function __call($methodname, $agrument) {
if($methodname == 'sum2') {
if(count($agrument) == 2) {
$this->sum($agrument[0], $agrument[1]);
}
if(count($agrument) == 3) {
echo $this->sum1($agrument[0], $agrument[1], $agrument[2]);
}
}
}
public function sum($a, $b) {
return $a + $b;
}
public function sum1($a,$b,$c) {
return $a + $b + $c;
}
}
$object = new overload('Sum');
echo $object->sum2(1,2,3);
Antwoord 5, autoriteit 3%
Hoewel het overbelastingsparadigma niet volledig wordt ondersteund door PHP, kan hetzelfde (of een vergelijkbaar) effect worden bereikt met standaardparameter(s) (zoals iemand eerder al zei).
Als u uw functie als volgt definieert:
function f($p=0)
{
if($p)
{
//implement functionality #1 here
}
else
{
//implement functionality #2 here
}
}
Als je deze functie aanroept als:
f();
je krijgt één functionaliteit (#1), maar als je het aanroept met een parameter zoals:
f(1);
je krijgt een andere functionaliteit (#2). Dat is het effect van overbelasting – verschillende functionaliteit afhankelijk van de invoerparameter(s) van de functie.
Ik weet het, iemand zal nu vragen welke functionaliteit je krijgt als hij/zij deze functie als f(0) aanroept.
Antwoord 6, autoriteit 2%
Overbelasting van methoden treedt op wanneer twee of meer methoden met dezelfde methodenaam maar een verschillend aantal parameters in één klasse zijn.
PHP ondersteunt geen overbelasting van methoden.
Methode overschrijven betekent twee methoden met dezelfde methodenaam en hetzelfde aantal parameters in twee verschillende klassen betekent bovenliggende klasse en onderliggende klasse.
Antwoord 7
Ik wil er hier op wijzen dat overbelasting in PHP een heel andere betekenis heeft in vergelijking met andere programmeertalen. Veel mensen hebben gezegd dat overbelasting niet wordt ondersteund in PHP en volgens de conventionele definitie van overbelasting is die functionaliteit niet expliciet beschikbaar.
De juiste definitie van overbelasting in PHP is echter compleet anders.
In PHP verwijst overbelasting naar het dynamisch creëren van eigenschappen en methoden met behulp van magische methoden zoals __set() en __get(). Deze overbelastingsmethoden worden aangeroepen bij interactie met methoden of eigenschappen die niet toegankelijk of niet gedeclareerd zijn.
Hier is een link uit de PHP-handleiding: http:// www.php.net/manual/en/language.oop5.overloading.php
Antwoord 8
Er zijn enkele verschillen tussen Functie-overbelasting & overschrijven, hoewel beide dezelfde functienaam bevatten. Bij overbelasting bevatten functies tussen dezelfde naam een ander type argument of retourtype; zoals:
“function add (int a,int b)” & “function add(float a,float b);
Hier is de functie add() overbelast.
In het geval van overschrijven zijn zowel het argument als de functienaam hetzelfde. Het wordt meestal gevonden in overerving of in eigenschappen. We moeten enkele tactieken volgen om te introduceren welke functie nu zal worden uitgevoerd.
Dus bij het overschrijven volgt de programmeur enkele tactieken om de gewenste functie uit te voeren, waarbij het programma bij overbelasting automatisch de gewenste functie kan identificeren…Bedankt!
Antwoord 9
Overbelasting:In de echte wereld betekent overbelasting dat u wat extra dingen aan iemand toewijst. Net als in de echte wereld Overbelasting in PHP betekent het aanroepen van extra functies. Op een andere manier kun je zeggen dat het een slankere functie heeft met een andere parameter. In PHP kun je overbelasting gebruiken met magische functies, b.v. __get, __set, __call enz.
Voorbeeld van overbelasting:
class Shape {
const Pi = 3.142 ; // constant value
function __call($functionname, $argument){
if($functionname == 'area')
switch(count($argument)){
case 0 : return 0 ;
case 1 : return self::Pi * $argument[0] ; // 3.14 * 5
case 2 : return $argument[0] * $argument[1]; // 5 * 10
}
}
}
$circle = new Shape();`enter code here`
echo "Area of circle:".$circle->area()."</br>"; // display the area of circle Output 0
echo "Area of circle:".$circle->area(5)."</br>"; // display the area of circle
$rect = new Shape();
echo "Area of rectangle:".$rect->area(5,10); // display area of rectangle
Overschrijven :In objectgeoriënteerd programmeren is overschrijven het vervangen van de bovenliggende methode in de onderliggende klasse. Bij overschrijven kunt u de bovenliggende klassemethode opnieuw declareren in de onderliggende klasse. Het doel van overschrijven is dus om het gedrag van je bovenliggende klassenmethode te veranderen.
Voorbeeld van overschrijven:
class parent_class
{
public function text() //text() is a parent class method
{
echo "Hello!! everyone I am parent class text method"."</br>";
}
public function test()
{
echo "Hello!! I am second method of parent class"."</br>";
}
}
class child extends parent_class
{
public function text() // Text() parent class method which is override by child
class
{
echo "Hello!! Everyone i am child class";
}
}
$obj= new parent_class();
$obj->text(); // display the parent class method echo
$obj= new parent_class();
$obj->test();
$obj= new child();
$obj->text(); // display the child class method echo
Antwoord 10
PHP 5.x.x ondersteunt geen overbelasting, daarom is PHP niet volledig OOP.