Qual è il sovraccarico e l'override della funzione in php?

In PHP, cosa intendi per sovraccarico della funzione e sostituzione della funzione. e qual è la differenza tra entrambi? non riuscivo a capire quale fosse la differenza tra loro.

Il sovraccarico sta definendo funzioni con firme simili, ma con parametri diversi. L'override è pertinente solo alle classi derivate, in cui la classe genitore ha definito un metodo e la classe derivata desidera sovrascrivere quel metodo.

In PHP, puoi solo sovraccaricare i metodi usando il metodo magico __call.

Un esempio di override :

<?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"
?>

Il sovraccarico della funzione si verifica quando si definisce lo stesso nome di funzione due volte (o più) utilizzando diversi set di parametri. Per esempio:

class Addition {
  function compute($first, $second) {
    return $first+$second;
  }

  function compute($first, $second, $third) {
    return $first+$second+$third;
  }
}

Nell'esempio sopra, la funzione computeè sovraccaricata con due diverse firme dei parametri. * Questo non è ancora supportato in PHP. Un'alternativa è usare argomenti opzionali:

class Addition {
  function compute($first, $second, $third = 0) {
    return $first+$second+$third;
  }
}

La sostituzione della funzione si verifica quando si estende una classe e si riscrive una funzione esistente nella classe padre:

class Substraction extends Addition {
  function compute($first, $second, $third = 0) {
    return $first-$second-$third;
  }
}

Ad esempio, computesovrascrive il comportamento indicato in Addition.

A rigor di termini, non c'è differenza, dal momento che non puoi fare neanche :)

La sostituzione delle funzioni avrebbe potuto essere eseguita con un'estensione PHP come APD, ma è obsoleta e l'ultima versione era inutilizzabile.

Il sovraccarico delle funzioni in PHP non può essere eseguito a causa della tipizzazione dinamica, ovvero in PHP non si "definiscono" le variabili come un tipo particolare. Esempio:

$a=1;
$a='1';
$a=true;
$a=doSomething();

Ogni variabile è di un tipo diverso, ma puoi conoscerne il tipo prima dell'esecuzione (vedi la quarta). Come confronto, altre lingue usano:

int a=1;
String s="1";
bool a=true;
something a=doSomething();

Nell'ultimo esempio, è necessario impostare con forza il tipo di variabile (ad esempio, ho usato il tipo di dati "qualcosa").

Un altro "problema" per cui il sovraccarico delle funzioni non è possibile in PHP: PHP ha una funzione chiamata func_get_args (), che restituisce una matrice di argomenti correnti, ora considera il seguente codice:

function hello($a){
  print_r(func_get_args());
}

function hello($a,$a){
  print_r(func_get_args());
}

hello('a');
hello('a','b');

Considerando che entrambe le funzioni accettano qualsiasi quantità di argomenti, quale dovrebbe scegliere il compilatore?

Infine, vorrei sottolineare perché le risposte di cui sopra sono parzialmente sbagliate; la funzione di sovraccarico / override NON è uguale al metodo di sovraccarico / override.

Laddove un metodo è come una funzione ma specifico di una classe, nel qual caso PHP consente l'override nelle classi, ma di nuovo nessun sovraccarico, a causa della semantica del linguaggio.

Per concludere, linguaggi come Javascript consentono l'override (ma di nuovo, nessun sovraccarico), tuttavia possono anche mostrare la differenza tra l'override di una funzione utente e un metodo:

/// 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'

Esempio di sovraccarico

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

Sebbene il paradigma di sovraccarico non sia pienamente supportato da PHP, lo stesso effetto (o molto simile) può essere ottenuto con i parametri predefiniti (come qualcuno menzionato prima).

Se definisci la tua funzione in questo modo:

function f($p=0)
{
  if($p)
  {
    //implement functionality #1 here
  }
  else
  {
    //implement functionality #2 here
  }
}

Quando chiamate questa funzione come:

f();

otterrai una funzionalità (# 1), ma se la chiami con un parametro come:

f(1);

otterrai un'altra funzionalità (# 2). Questo è l'effetto del sovraccarico: funzionalità diverse a seconda dei parametri di input della funzione.

Lo so, qualcuno ora chiederà quale funzionalità si otterrà se chiama questa funzione come f (0).

Vorrei sottolineare qui che il sovraccarico in PHP ha un significato completamente diverso rispetto ad altri linguaggi di programmazione. Molte persone hanno affermato che il sovraccarico non è supportato in PHP e dalla definizione convenzionale di sovraccarico, sì, la funzionalità non è esplicitamente disponibile.

Tuttavia, la corretta definizione di sovraccarico in PHP è completamente diversa.

In PHP il sovraccarico si riferisce alla creazione dinamica di proprietà e metodi usando metodi magici come __set () e __get (). Questi metodi di sovraccarico vengono richiamati quando si interagisce con metodi o proprietà non accessibili o non dichiarati.

Ecco un link dal manuale di PHP: http://www.php.net/manual/en/language.oop5.overloading.php

Il sovraccarico del metodo si verifica quando due o più metodi con lo stesso nome di metodo ma un numero diverso di parametri nella singola classe. PHP non supporta il sovraccarico del metodo. La sostituzione del metodo significa due metodi con lo stesso nome di metodo e lo stesso numero di parametri in due classi diverse significa classe padre e classe figlio.

Esistono alcune differenze tra il sovraccarico e l'override della funzione sebbene entrambi contengano lo stesso nome di funzione. In caso di sovraccarico, tra lo stesso nome le funzioni contengono un diverso tipo di argomento o tipo di ritorno; Ad esempio: "funzione add (int a, int b)" & " funzione add (float a, float b); qui la funzione add () è sovraccarica. In caso di sostituzione sia l'argomento che il nome della funzione sono gli stessi. Si trova generalmente in eredità o in tratti. Dobbiamo seguire alcune tattiche per introdurre , quale funzione verrà eseguita ora. Quindi, nel sovrascrivere il programmatore segue alcune tattiche per eseguire la funzione desiderata in cui nel sovraccarico il programma può identificare automaticamente la funzione desiderata ... Grazie!

Sovraccarico: nel mondo reale, sovraccarico significa assegnare alcune cose extra a qualcuno. Come nel mondo reale Il sovraccarico in PHP significa chiamare funzioni extra. In un altro modo puoi dire che ha una funzione più slimier con parametri diversi. In PHP puoi usare il sovraccarico con funzioni magiche come __get, __set, __call ecc.

Esempio di sovraccarico:

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

Sostituzione: nella programmazione orientata agli oggetti la sostituzione consiste nel sostituire il metodo padre nella classe figlio. Nella sostituzione è possibile dichiarare nuovamente il metodo della classe padre nella classe figlio. Quindi, fondamentalmente lo scopo della sostituzione è quello di cambiare il comportamento del metodo della classe genitore.

Esempio di sostituzione:

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

PHP 5.xx non supporta il sovraccarico, ecco perché PHP non è completamente OOP.