Extending static classes in PHP - Avoiding sharing variables for multiple classes in extended class

This appears to still be an issue in php 7.3 (7 years after the original question here was posted).

The answer using __callStatic looks like it probably works, but it's pretty complicated for something that should be simple. And the other 2 answers don't seem to actually offer a working solution to the issue, so I'm including my own workaround as an answer here.

You can replace the static variable with a static array:

<?php
    class InstanceModule {
        public static $className = [];
        public static function PrintClassName() {
            $calledClass = get_called_class();
            if(empty(self::$className[$calledClass])){
              $thisClassName = "none";
            }else{
              $thisClassName = self::$className[$calledClass];
            }
            echo $thisClassName . ' (' . __CLASS__ . ')<br />';
        }
    }

    class A extends InstanceModule {
        public static function Construct() {
            $calledClass = get_called_class();
            self::$className[$calledClass] = "A";
        }
    }

    class B extends InstanceModule {
        public static function Construct() {
            $calledClass = get_called_class();
            self::$className[$calledClass] = "B";
        }
    }
?>

So the "static" value for each child class of InstanceModule is stored under a key having the name of the class it originates from.

To me, it seems like a PHP bug that sibling classes would share static properties.... that should never happen, especially when the parent is abstract. This workaround isn't super pretty, but it's the only method I've gotten to work that isn't too complicated.

With this workaround, you get the desired results:

<?php   
    A::PrintClassName(); //Expected 'None' - actual result: 'None'
    B::PrintClassName(); //Expected 'None' - actual result: 'None'

    A::Construct();

    A::PrintClassName(); //Expected 'A' - actual result: 'A'
    B::PrintClassName(); //Expected 'None' - actual result: 'None'

    B::Construct();

    A::PrintClassName(); //Expected 'A' - actual result: 'A'
    B::PrintClassName(); //Expected 'B' - actual result: 'B'

    A::Construct();

    A::PrintClassName(); //Expected 'A' - actual result: 'A'
    B::PrintClassName(); //Expected 'B' - actual result: 'B'
?>

I would have the base class keep a repository of sub class instances, so that you can properly separate data that belongs to each class rather than pulling that data from a static base class variable.

You can use the __callStatic() magic method on the base class to accomplish calling methods on non-existent sub classes, as demonstrated below. Unfortunately, the static repository variable needs to be declared public due to the visibility of that magic method.

abstract class Base
{
    public static $repo = array();

    public static function __callStatic($name, $args)
    {
        $class = get_called_class();

        if (!isset(self::$repo[$class])) {
                echo "Creating instance of $class\n";
                self::$repo[$class] = new $class();
        }

        return call_user_func_array(array(self::$repo[$class], $name), $args);
    }

        protected function PrintClassName()
        {
                echo __CLASS__, " (", get_called_class(), ")\n";
        }

        protected abstract function Construct($a);
}

class A extends Base
{
        protected function Construct($a)
        {
                echo __CLASS__, ": setting x := $a\n";
        }
}

class B extends Base
{
        protected function Construct($a)
        {
                echo __CLASS__, ": setting y := $a\n";
        }
}

A::PrintClassName();
B::PrintClassName();

A::Construct('X');
B::Construct('Y');

Output:

Creating instance of A
Base (A)
Creating instance of B
Base (B)
A: setting x := X
B: setting y := Y

I think the best answer to your situation is to use the get_called_class() function instead of your current $className variable, which will return the late static binding class name instead of __CLASS__ or get_class() which will only return the current class name.

If you changed your PrintClassName() function to just output what get_called_class() returned, your output would be the following. Now you'd just need to incorporate a default value, which of course will be shared across the classes, so you'd have to have that flag in both classes if you're going to continue using static methods.

A
B
A
B
A
B
A
B