{"id":183,"date":"2017-02-10T14:33:10","date_gmt":"2017-02-10T14:33:10","guid":{"rendered":"https:\/\/miklcct.com\/wordpress\/?p=183"},"modified":"2017-04-01T08:47:27","modified_gmt":"2017-04-01T08:47:27","slug":"static-in-php","status":"publish","type":"post","link":"https:\/\/miklcct.com\/wordpress\/2017\/02\/10\/static-in-php\/","title":{"rendered":"static in PHP"},"content":{"rendered":"

static<\/code> keyword is used to represent class members, i.e. members which are shared among the class, as opposed of instance members which is unique to an object instance, in many programming languages, including PHP. However, the static functionality in PHP is much more powerful than in some other traditional programming languages, for example, C++ and Java, because in PHP polymorphism can also be achieved using static members in addition to instance members.<\/p>\n

In C++ and Java, a static member is always resolved at compile time using the declared type. Using the following code as an example:<\/p>\n

C++ code:<\/p>\n

#include <iostream>\r\n#include <string>\r\nusing std::cout;\r\nusing std::string;\r\n\r\nclass Base {\r\npublic:\r\n    static string hello() {\r\n        return message;\r\n    }\r\nprotected:\r\n    static string message;\r\n};\r\n\r\nclass Intermediate : public Base {\r\nprotected:\r\n    static string message;\r\n};\r\n\r\nclass Derived : public Intermediate {\r\npublic:\r\n    static string hello() {\r\n        return \"Derived: \" + message;\r\n    }\r\nprotected:\r\n    static string message;\r\n};\r\n\r\nstring Base::message = \"Hello!\";\r\nstring Intermediate::message = \"Howdy!\";\r\nstring Derived::message = \"Hi!\";\r\n\r\nvoid test(Base *object) {\r\n    cout << Intermediate::hello() << '\\n';\r\n    cout << object->hello() << '\\n';\r\n}\r\n\r\nint main() {\r\n    test(new Derived());\r\n    return 0;\r\n}\r\n<\/pre>\n
Java code:<\/p>\n
class Base {\r\n    protected static String message = \"Hello!\";\r\n    public static String hello() {\r\n        return message;\r\n    }\r\n}\r\n\r\nclass Intermediate extends Base {\r\n    protected static String message = \"Howdy!\";\r\n}\r\n\r\nclass Derived extends Intermediate {\r\n    protected static String message = \"Hi!\";\r\n    public static String hello() {\r\n        return \"Derived: \" + message;\r\n    }\r\n}\r\n\r\npublic class Main {\r\n    private static void test(Base object) {\r\n        System.out.println(Intermediate.hello());\r\n        System.out.println(object.hello());\r\n    }\r\n\r\n    public static void main(String[] args) {\r\n        test(new Derived());\r\n    }\r\n}\r\n<\/pre>\n
Both programs outputs<\/p>\n
Hello!\r\nHello!\r\n<\/pre>\n
when run, indicating Base::hello()<\/code> is called with message<\/code> resolved to Base::message<\/code> inside Base::hello()<\/code>. It is because, in both C++ and Java, all static members are resolved using the static (i.e. declared) type of the expression, which means object->hello()<\/code> is the same as Base::hello()<\/code> because object<\/code> is declared to be of type Base *<\/code>. Moreover, inside Base::hello()<\/code>, message<\/code> refers to Base::message<\/code> because the scope is in class Base<\/code>. The fact that hello()<\/code> is called using Intermediate::hello()<\/code> does not matter.<\/p>\n
Now consider the following piece of similar PHP code:<\/p>\n
<?php\r\nclass Base {\r\n    protected static $message = \"Hello!\";\r\n    public static function hello() {\r\n        return self::$message;\r\n    }\r\n}\r\n\r\nclass Intermediate extends Base {\r\n    protected static $message = \"Howdy!\";\r\n}\r\n\r\nclass Derived extends Intermediate {\r\n    protected static $message = \"Hi!\";\r\n    public static function hello() {\r\n        return \"Derived: \" . self::$message;\r\n    }\r\n}\r\n\r\nfunction test(Base $object) {\r\n    echo Intermediate::hello() . \"\\n\";\r\n    echo $object->hello() . \"\\n\";\r\n}\r\n\r\ntest(new Derived());\r\n<\/pre>\n
Running the PHP code gets:<\/p>\n
Hello!\r\nDerived: Hi!\r\n<\/pre>\n
which indicates that Derived::hello()<\/code> get called in $object->hello()<\/code> despite $object<\/code> being declared as a Base<\/code> in the function header. It is because, despite the type declaration in the function header, PHP is a dynamically-typed language where types are only associated with value but not the expression itself, which means the expression $object<\/code> is not associated with a type without regarding to its value. The type declaration is only checked when an argument is passed into it at the point of calling and unused afterwards. It is not an error to reassign $object<\/code> to something else inside the function. Therefore, when calling $object->hello()<\/code>, the type of $object<\/code> is retrieved from the $object<\/code> at runtime, therefore, Derived::hello()<\/code> is called because $object<\/code> is a Derived<\/code>.<\/p>\n
For the call to Intermediate::hello()<\/code>, the effect is the same as in C++ and Java, where the keyword self<\/code> resolves to the class where the function is in. However, if we replace the keyword self<\/code> by static<\/code>, magic<\/i> happens, which works for PHP version at least 5.3:<\/p>\n
<?php\r\nclass Base {\r\n    protected static $message = \"Hello!\";\r\n    public static function hello() {\r\n        return static::$message;\r\n    }\r\n}\r\n\r\nclass Intermediate extends Base {\r\n    protected static $message = \"Howdy!\";\r\n}\r\n\r\nclass Derived extends Intermediate {\r\n    protected static $message = \"Hi!\";\r\n    public static function hello() {\r\n        return \"Derived: \" . static::$message;\r\n    }\r\n}\r\n\r\nfunction test(Base $object) {\r\n    echo Intermediate::hello() . \"\\n\";\r\n    echo $object->hello() . \"\\n\";\r\n}\r\n\r\ntest(new Derived());\r\n<\/pre>\n
Running the above code shows:<\/p>\n
Howdy!\r\nDerived: Hi!\r\n<\/pre>\n
Now, in the call of Intermediate::hello()<\/code>, Intermediate::$message<\/code> is returned from the function! The $message<\/code> member in Intermediate<\/code> has overridden<\/i> the Base<\/code> member and polymorphism is exhibited as the function in Base<\/code> got the value of Intermediate::$message<\/code>.<\/p>\n
The magic is that, starting from PHP 5.3, static function calls have an implicit static<\/code> scope, just like non-static function calls having an implicit $this<\/code> variable. The static<\/code> scope is set by the language to be the class where the function is called, i.e., in the call of Intermediate::hello()<\/code> the static<\/code> scope is Intermediate<\/code>, and in the call of $object->hello()<\/code> the static<\/code> scope is Derived<\/code> because $object<\/code> is of type Derived<\/code> (compared to the fact that, if hello()<\/code> were non-static, $this<\/code> would be set to $object<\/code>). Furthermore, calling methods using self::<\/code>, static::<\/code> or parent::<\/code> also forwards the static<\/code> scope to the called method.<\/p>\n
Using this feature, it is possible to do class-based polymorphism in PHP using static methods, properties and class constants, which serves as a complement to normal polymorphism using objects. In modern PHP version static methods are subject to compatibility rules regarding function signature if overriden, can be declared abstract, and can be placed inside interfaces, just like non-static functions. You can even use new static<\/code> in factory methods to create objects of child classes without any knowledge of them as long as the child constructor is compatible with the parent constructor, which is impossible in Java without using reflection.<\/p>\n","protected":false},"excerpt":{"rendered":"
static keyword is used to represent class members, i.e. members which are shared among the class, as opposed of instance members which is unique to an object instance, in many programming languages, including PHP. However, the static functionality in PHP is much…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[38],"class_list":["post-183","post","type-post","status-publish","format-standard","hentry","category-programming","tag-static"],"_links":{"self":[{"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/posts\/183","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/comments?post=183"}],"version-history":[{"count":2,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/posts\/183\/revisions"}],"predecessor-version":[{"id":186,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/posts\/183\/revisions\/186"}],"wp:attachment":[{"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/media?parent=183"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/categories?post=183"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/miklcct.com\/wordpress\/wp-json\/wp\/v2\/tags?post=183"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}