chiamare un metodo statico all'interno di una classe?

come posso chiamare un metodo statico da un altro metodo all'interno della stessa classe?

$this->staticMethod();

o

$this::staticMethod();

self::staticMethod();

Ulteriori informazioni sulla parola chiave statica.

Supponiamo che questa sia la tua classe:

class Test
{
    private $baz = 1;

    public function foo() { ... }

    public function bar() 
    {
        printf("baz = %d\n", $this->baz);
    }

    public static function staticMethod() { echo "static method\n"; }
}

Dall'interno del foo()metodo, diamo un'occhiata alle diverse opzioni:

$this->staticMethod();

Quindi questo chiama staticMethod()un metodo di istanza, giusto? Non è così. Questo perché il metodo viene dichiarato come public staticl'interprete lo chiamerà come metodo statico, quindi funzionerà come previsto. Si potrebbe sostenere che farlo rende meno ovvio dal codice che sta avvenendo una chiamata di metodo statico.

$this::staticMethod();

Da PHP 5.3 puoi usare $var::method()per significare <class-of-$var>::; questo è abbastanza conveniente, sebbene il caso d'uso sopra riportato sia ancora piuttosto non convenzionale. Questo ci porta al modo più comune di chiamare un metodo statico:

self::staticMethod();

Ora, prima di iniziare a pensare che ::sia l' operatore di chiamata statica, lascia che ti dia un altro esempio:

self::bar();

Questo stamperà baz = 1, il che significa che $this->bar()e self::bar()farà esattamente la stessa cosa; questo perché ::è solo un operatore di risoluzione dell'ambito. E 'lì per fare parent::, self::e static::il lavoro e consentono di accedere a variabili statiche; come viene chiamato un metodo dipende dalla sua firma e da come è stato chiamato il chiamante.

Per vedere tutto questo in azione, vedi questo output di 3v4l.org .

Questa è una risposta molto tardiva, ma aggiunge alcuni dettagli sulle risposte precedenti

Quando si tratta di chiamare metodi statici in PHP da un altro metodo statico sulla stessa classe, è importante distinguere tra selfe il nome della classe.

Prendi ad esempio questo codice:

class static_test_class {
    public static function test() {
        echo "Original class\n";
    }

    public static function run($use_self) {
        if($use_self) {
            self::test();
        } else {
            $class = get_called_class();
            $class::test(); 
        }
    }
}

class extended_static_test_class extends static_test_class {
    public static function test() {
        echo "Extended class\n";
    }
}

extended_static_test_class::run(true);
extended_static_test_class::run(false);

L'output di questo codice è:

Classe originale

Classe estesa

Questo perché si selfriferisce alla classe in cui si trova il codice, piuttosto che alla classe del codice da cui viene chiamata.

Se si desidera utilizzare un metodo definito su una classe che eredita la classe originale, è necessario utilizzare qualcosa del tipo:

$class = get_called_class();
$class::function_name(); 

Anche nella versione successiva di PHP self::staticMethod();non funzionerà. Emetterà il rigoroso errore standard.

In questo caso, possiamo creare un oggetto della stessa classe e chiamare per oggetto

ecco l'esempio

class Foo {

    public function fun1() {
        echo 'non-static';   
    }

    public static function fun2() {
        echo (new self)->fun1();
    }
}