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


Risposte:


192

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

31
PHP non supporta il sovraccarico, però.
Sasha Chedygov,

18
Sì lo fa, usando __call.
Jacob Relkin,

50
PHP sostituisce il sovraccarico tramite parametri opzionali.
b01,

3
Grazie per l'idea di parametri opzionali, è un suggerimento davvero utile
Fabricio PH

2
__call () viene attivato quando vengono chiamati metodi inaccessibili nel contesto degli oggetti __callStatic () il metodo megic viene attivato quando vengono chiamati metodi inaccessibili nel contesto statico. Seguire questo per ottenere un esempio più dettagliato e una spiegazione del sovraccarico nel contesto di PHP
Code Buster

107

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.


9
Tranne il sovraccarico della funzione non è supportato in PHP, AFAIK. Inoltre, come nota a margine non correlata, non sono sicuro del motivo per cui una Subtractionclasse dovrebbe estenderla Addition. :)
Sasha Chedygov l'

6
@musicfreak: 00:40 ora locale ... Non riuscivo a pensare a un esempio migliore.
Andrew Moore,

5
Questo non è ancora supportato in PHP e probabilmente non lo farà mai, poiché PHP è un linguaggio debolmente tipizzato e in questo caso non cambierà nulla.
Crozin,

2
Il sovraccarico non è solo quando si definisce lo stesso nome di funzione due volte (o più volte) utilizzando diversi set di parametri. In genere, il sovraccarico si verifica anche quando si definisce lo stesso nome di funzione due volte (o più volte) utilizzando lo stesso numero di parametri ma di tipi diversi. Poiché in PHP non esiste una dichiarazione di tipo variabile (come in Java) questa generalizzazione non ha importanza. Sto solo citando questo per motivi di precisione di cosa sia il sovraccarico.
sbrbot,

2
@sbrbot: Set implica sia il numero che i tipi.
Andrew Moore,

22

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'

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

30
Non è che PHP non supporti il ​​sovraccarico, è che non ha senso. Il problema è dovuto al fatto che PHP utilizza tipi dinamici. In effetti, Javascript non supporta neanche il sovraccarico ed è ancora OOP. Il fud "PHP non è completamente OOP" esiste solo perché alcune persone hanno deciso di utilizzare una lista di controllo per giudicare ciò che è OOP o no.
Christian,

@ ringø No, le funzioni denominate in PHP sono immutabili. Una volta creata una funzione con nome in PHP, non è possibile modificarne il comportamento interno (sostituzione). A meno che tu non intendessi il metodo override, che è qualcos'altro .. Probabilmente dovresti leggere l'intera risposta prima di commentare sulla prima riga. :)
Christian,

@Christian Bene, ovviamente in PHP (e in molte altre lingue) si verifica la priorità in una classe . Quindi, sì, stiamo parlando di metodi, anche se ognuno di essi ha il prefisso con la funzione parola chiave . Ma in effetti avrei dovuto prima leggere l'intera risposta ...
e2-e4,

9

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

Bella implementazione personalizzata, ma dovrebbe essere data dalla lingua.
OGNI

Questo non è un metodo, sovraccarico di funzioni, mentre stai usando un nome di metodo diverso per ogni studente
TomSawyer

5

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


1

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


1

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.


0

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!


0

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

-14

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


18
Non so dove hai avuto l'idea che sovraccaricare un requisito per la programmazione orientata agli oggetti.
Drewish

6
@drewish perché il polimorfismo parametrico è una delle caratteristiche più importanti di OOP?
Davor

1
@drewish se si considera il polimorfismo come una delle principali stagnazioni di OOP. Quindi il sovraccarico apparentemente è là fuori per la compilazione. Tuttavia, il sovraccarico del metodo è il polimorfismo del tempo di compilazione e noto anche come polimorfismo statico.
Yasir Arefin,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.