Demonstrate self parent and keywords in terms of static members with examples in php

It’s important to note that the self:: keyword can be used for both static and non-static class members, but it throws an error when you try to access a non-static member from a static method, but not vice-versa. 

Here are some code snippets to illustrate what this means:

otherStaticMethod(); // A

In the sample above, we were able to call a static method from another static method using the self:: keyword. We could also do this by using the $this→ accessor.

As seen in the first code snippet, we can also access static methods from other static methods using the self:: keyword.

nonStaticMethod(); // I am staticI am not static

As seen in the example above, using a static method in a non-static method runs without problems.

Using a non-static method in a static method causes an error. The same rules applied here also apply for static:: and parent:: in PHP.

The parent:: Accessor

The parent:: accessor is a rather specific and exact keyword. It refers to methods and properties in a parent class from the scope of a child class. Since the child class should override the properties by default, the accessor can explicitly refer to the parent class’s property. 

It is also handy when both classes have properties with the same name. 

The static:: Accessor

In order to see this, let’s look at this snippet of code:

As seen in this example, using the self:: method causes some unexpected behavior when we extend the class using it. We would naturally expect the standard rules of inheritance that the makeSound() method should be overridden by the Dog class, but that isn’t the case. 

This happens because when we use self::, we refer to the property class that used the self:: keyword, not any other child-class that extends it.

Any method we access using the self:: keyword won’t get overridden by child classes. This may not be the behavior we expect.

Take a break and check out the ultimate guide to Laravel 2021 to be up-to-date with Laravel Development.

In PHP v5.3, a new feature called late static binding was implemented. The feature allows us to use the class named in the last call of a property. 

This means when you use the static:: accessor, the method won’t be resolved until runtime, and during runtime, PHP will check for the last class that defines that method during the call. This would give us the kind of overriding mechanism we would expect. 

Here’s an example:

As seen in the code sample above, using the static:: makes the makeSound method to be accessed at runtime on the class that overrides it. That is why accessing vocalize from the different classes behaves the way we would expect it to.

Caveat with static:: when using with private non-static methods

Private methods (and all properties) can only be accessed within the class that defines them. Parent classes can’t access them. When using the static:: accessor to access private static methods in child classes, it will fail. 

This is because when we access child (overridden) methods in child classes with the static:: keyword, we are trying to access them from the scope of the parent class. 

If the overridden method is private, at runtime, it will try to access the method it finds from the last class calling it (which is private) from the scope of the parent class, and since the parent class can’t access that method because it’s private, the code will fail. 

Here’s an example:

test(); // Fails because the private function's scope is in C and trying to access it from A will fail

Using self::foo() or $this→foo() in class A would have worked without error, but it would echo “success!” and not “failure” because they would be referring to the foo() method in Class A, not the one in Class C. 

Conclusion

We learned a bit about inheritance and different accessors such as self::, static:: parent::, we can use when working with OOP in PHP. These accessors help us write clean code implementing the use of inheritance and polymorphism. 

With these, we can build efficient data structures that make our projects easy to build, scale, and understand even if we hand off our code to others.

We hope we’ve helped you learn something new, and if you did, let us know in the comments.

Catch you in the next one!