The use of the final static const keyword in PHP object-oriented

This keyword can only be used to define classes and methods. The final keyword cannot be used to define member properties, because final means constant. We use the define() function to define constants in PHP, so final cannot be used. to define member properties.

14. Application of the final keyword
This keyword can only be used to define classes and methods. The final keyword cannot be used to define member properties, because
final means constant. We define constants in PHP using is the define() function, so final cannot be used to define member properties.
Classes marked with the final key cannot be inherited;
Code snippets
final class Person{
… …
}
class Student extends Person{
}
The following error will appear:
Fatal error: Class Student may not inherit from final class (Person)
Methods marked with the final key cannot be overridden by subclasses and are the final version;
code snippet
class Person{
final function say() {
}
}
class Student extends Person{
function say() {
}
}
The following error will occur:
Fatal error: Cannot override final method Person::say()
15. Use of static and const keywords
Static keyword is to describe member properties and member methods in the class as static ;What are the benefits of static members?
We declared the human being "Person" earlier. If we add an attribute of "the country to which the person belongs" to the "Person" class, hundreds or more instances can be instantiated using the "Person" class. Object, each object has the attribute of "country to which it belongs". If the project is developed for the Chinese, then each object has the attribute of "China" and other attributes of the country. is different. If we make the "country" attribute a static
member, then there will be only one country attribute in the memory, and let hundreds or more objects share this attribute, the
static member can Restrict external access, because static members belong to the class and do not belong to any object instance. It is the space allocated when the class is loaded for the first time. It is inaccessible to other classes and is only shared with instances of the class. It can protect the members of the class to a certain extent; Let’s analyze it from the perspective of memory. The memory is logically divided into four segments, in which the object is placed in the "heap memory", and the reference of the object is placed in the "heap memory". In the "stack memory", the static members are placed in the "initialization static segment", which is placed when the class is loaded for the first time. It can be shared by every object in the heap memory, as shown below;


Static variables of a class are very similar to global variables and can be shared by all instances of the class. The same is true for static methods of a class
, similar to global functions.
Code snippet



Copy the code
The code is as follows:


class Person{

//The following are the static member attributes of the person public static $myCountry="China"; // var $name ; //The name of the person //This is the static member method of the person public static function say(){

echo "I am Chinese
";

}
}
//Output static attributes
echo Person::$myCountry;
//Access static methods
Person::say();
//Reassign static properties
Person::$myCountry="United States";
echo Person::$myCountry;
?> ;


Because static members are created when the class is loaded for the first time, you can access the static members by using the class
name without requiring an object outside the class; as mentioned above, static members are used by every member of this class. Shared by an instance object, then can we access static members in a class using objects? From the picture above, we can see that static members do not exist inside each object, but each object can be shared, so if we use objects to access members, there will be no such attribute definition and use object access. If there are no static members, in other object-oriented languages, such as Java, you can use objects to access static members. If you can use objects to access static members in PHP, we should try not to use them because static members When we are working on a project, our purpose is to use the class name to access the members.
Static methods in a class can only access the static attributes of the class. Static methods in the class cannot access non-static members of the class. The reason is very simple. We want to access this class in the method of this class. For other members, we need to use the reference $this
, and the reference pointer $this represents the object that calls this method. We said that static methods are not called with objects
, but are accessed using the class name, so it is simply If no object exists, there is no reference to $this. Without the reference to $this, non-static members in the class cannot be accessed. And because static members in the class can be accessed without objects, so the Static methods can only access static properties of the class. Since $this does not exist, we use a special class "self" to access other static members in the static method; self is similar to $this, except that self is the representative
The class where this static method is located. So in a static method, you can use the "class name" of the class where the method is located, or you can use "self" to access other static members. If there are no special circumstances, we usually use the latter, that is, "self::
member attribute" method.
Code snippet



Copy the code

The code is as follows:


class Person{
//The following are the static member attributes of the person

public static $myCountry="China"; //This is the person Static member methods, access other static members through self public static function say(){ echo "I am".self::$myCountry."
"; }

}

//Access static methods
Person::say();
?>


Can you access static members in non-static methods? Of course it is possible, but you cannot use "$this"
References must also use class names or " self::form of member attribute".
const is a keyword that defines constants. To define constants in PHP, you use the "define()" function, but
to define constants in a class, you use the "const" keyword, which is similar to # in C. define If its value is changed in the program, an error will occur. The member attributes modified with "const" are accessed in the same way as the members modified with "static". The "class name" is also used. In the method The "self" keyword is used inside. But you don't need to use the "$"
symbol, nor can you use objects to access it.
Code snippet

Copy the code

The code is as follows:


class MyClass{
//Define a constant constant
const constant = 'constant value';
function showConstant() {

echo self ::constant . "n"; //Use self to access, do not add "$" } } echo MyClass::constant . "n"; //Use class name to access, do not add "$" $ class = new MyClass();

$class->showConstant();

// echo $class::constant; is not allowed







The above introduces the use of the final static const keyword in PHP object-oriented, including the content. I hope it will be helpful to friends who are interested in PHP tutorials.