Question

I’m having difficulty understanding how ‘static’ stuff works in PHP. Can someone point me to a good tutorial on this? One that comprehensively covers the topic?

I understand the use of static variables within a function, and also static members in a class. Beyond that, however, it gets a bit hazy.

For example: I see that static methods can be called without instantiating a class. Not sure why this is important though, since you can call a non-static method in exactly the same way, provided it does not reference $this

Late static binding is another area of confusion, along with when and where I can use the scope resolution operator. (It seems I can use it to call parent methods irrespective of whether they are static or not…)

Am I the only one struggling with this?

Answer 1

While you can call a non-static method without an instance, this will trigger an E_STRICT warning. The whole point of static methods is for accessing static variables on the class, but many people use it as a way to logically group utility functions rather than define a bunch of global functions.

When you call a static method using the class’s name, e.g. Class::foo(), there is no instance and thus no polymorphism. The foo defined by Class is called directly. If it doesn’t define such a method, its superclasses are searched until one is found that does.

class Parent {
    static function foo() {
        echo "Parent::foo";
    }
    static function bar() {
        echo "Parent::bar";
    }
}

class Child extends Parent {
    static function foo() {
        echo "Child::foo";
    }
}

Parent::foo();   // Parent::foo
Parent::bar();   // Parent::bar

Child::foo();    // Child::foo
Child::bar();    // Parent::bar

When you call a static method using the self keyword from a class method, e.g. self::foo(), it works just as if you were to replace self with the name of the class holding the calling code.

class Parent {
    static function foo() {
        echo "Parent::foo";
    }
    static function callFoo() {
        self::foo();    // equivalent to Parent::foo()
    }
}

class Child extends Parent {
    static function foo() {
        echo "Child::foo";
    }
}

Parent::callFoo();   // Parent::foo
Child::callFoo();    // Parent::foo

When you call a static method using the static keyword from a class method, e.g. static::foo(), you are invoking late static binding. Instead of starting the search for foo in the current class, it starts from the current class context, the class that was initially statically-referenced.

class Parent {
    static function foo() {
        echo "Parent::foo";
    }
    static function callFoo() {
        static::foo();         // late static binding
    }
}

class Child extends Parent {
    static function foo() {
        echo "Child::foo";
    }
    static function callParentCallFoo() {
        Parent::callFoo();    // resets static context to Parent
    }
}

Parent::callFoo();             // Parent::foo
Child::callFoo();              // Child::foo
Child::callParentCallFoo();    // Parent::foo

Late static binding works similarly with static class properties, but the property must be defined in the child class itself. Assigning a new property to a class (e.g. Child::$foo = 'foo') will not make it available for LSB from the parent.