Difference between calling a non-static method statically and not statically

Question

Given the following code:

<?php
class MyClass {
    public function print() {
        echo $this->number . "\n";
    }

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

class MyExtendedClass extends MyClass {
    protected $number = 100;

    public function extendedPrint() {
        $this->print();
        $this::print(); // What's the difference?
        $this->staticPrint(); // Why is this allowed?
        $this::staticPrint();
        echo "Print done...!\n";
    }
}

$myExtendedClass = new MyExtendedClass();
$myExtendedClass->extendedPrint();

with the following output:

100
100
Print done...!

Is there any difference between $this->print() and $this::print() ?

http://stackoverflow.com/questions/4361598/php-static-and-non-static-functions-and-objects — salih0vicX, Oct 06 '16 at 07:32
Between `$this->print()` and `$this::print()` there is no difference. But between `$var->print()` and `$var::print()` there is (even inside class). See [my answer](http://stackoverflow.com/a/39891561/1421194). — Sasha, Oct 06 '16 at 09:21

I Putu Yoga Permana · Answer 1 · 2016-10-06T08:08:26.893

1

IMHO, there is no any difference if you call it from inside your class.

But, if you call it from outside your class, you need instantiate first to call non-static method.

$var = new MyExtendedClass;
$var->print();

Static: (deprecated on PHP 7)

$var = MyExtendedClass::print();

on PHP 7, you need Static keyword on your method, so it can be call statically. Full reference

edited Oct 06 '16 at 08:08

answered Oct 06 '16 at 07:37

I Putu Yoga Permana

3,980
29
33

`$var = MyExtendedClass::print();` you are calling a non-static method statically, in PHP 7.0 `$this` would be undefined. – zer0uno Oct 06 '16 at 07:45
@welcome : i acknowledged that, just updated my answer. – I Putu Yoga Permana Oct 06 '16 at 07:50
No, there is difference. See [my answer](http://stackoverflow.com/a/39891561/1421194). – Sasha Oct 06 '16 at 08:56

score 1 · Answer 2 · edited Jun 20 '20 at 09:12

A method which is declared as static will always be called statically:

public static function bar() { var_dump($this); }

Whichever way you call this method, it will result in:

Fatal error: Uncaught Error: Using $this when not in object context

_{(Or variations thereof depending on your version of PHP.)}

A function which does not have the static keyword behaves… differently:

class Foo {
    public function bar() { var_dump($this); }
}

$f = new Foo;
$f::bar();

Deprecated: Non-static method Foo::bar() should not be called statically
Fatal error: Uncaught Error: Using $this when not in object context

Calling the function from outside actually calls it statically.

class Foo {
    public function bar() { var_dump($this); }
    public function baz() { $this::bar(); }
}

$f = new Foo;
$f->baz();

object(Foo)#1 (0) {
}

Calling the function via $this:: calls it in an object context.

The manual only has these vague paragraphs to offer for the :: operator:

When referencing these items from outside the class definition, use the name of the class.

As of PHP 5.3.0, it's possible to reference the class using a variable. The variable's value can not be a keyword (e.g. self, parent and static).

It appears that outside a class :: always operates statically, and $f:: substitutes the name of the class. However, within an object context, :: preserves the context, likely to enable correct operation of parent:: calls, which obviously should preserve the object context.

score 0 · Answer 3 · answered Oct 06 '16 at 07:52

In the example you gave No, there is no difference.

Although there are totally different in most circumstances, since in the non-static you are printing the current number value of the object, which could have changed (any set method or similar could have been called).

Whereas with the static call it would print always the same value (default value declared in the class scope, 100).

Sasha · Answer 4 · 2016-10-06T09:08:09.013

The short answer is: $instance::method(…) (where $instance is a class instance, not a string) seems to be equivalent to get_class($instance)::method(…) (which in your case means MyExtendedClass::print()).

When you call SomeClassName::method(…), the fact whether the method receives or not receives a $this value is sporadic. It depends on what place you call SomeClassName::method(…) from. Calling SomeClassName::method(…) from within same or other method of the SomeClassName or its descendant will cause the $this from the place of calling to be passed to method; otherwise method probably won't receive any $this value.

Thus, when you call $instance::method(…), the method may or may not receive a $this value. If it receives a $this value, it will be the $this value from the place of calling, but not the $instance (although they may coincide, as when doing $this::method(…) or $instance = $this; …; $instance::method(…)).

http://sandbox.onlinephpfunctions.com/code/93d4ea2dd47dbc2c5ed338a96ca4d00d4ffef77b

Difference between calling a non-static method statically and not statically

4 Answers4

Linked