PHP object-oriented guide (10) Use of final static const keyword_PHP tutorial

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, which we define in PHP. Constants use the define() function, so final cannot be used to define member properties.
Classes marked with the final key cannot be inherited;
Code snippet
final class Person{
… …
}
class Student extends Person{
}
Yes The following error occurs:
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 describes member properties and member methods in the class as static; static members What are the benefits?
Earlier we declared the human being "Person". In the "Person" class, if we add an attribute of "the country to which the person belongs"
, we can use the "Person" class to instantiate hundreds or more There are more instance objects, and each object will have
the attribute of "country to which it belongs." If the project is developed for Chinese people, then each object will have
a country attribute. The attribute is "China" and other attributes are different. If we make the "country" attribute a static
member, then there will be only one country attribute in the memory, and there will be hundreds or more Objects share this attribute.
static members 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. Other classes are inaccessible and are only shared with instances of the class. This member of the class can be protected to a certain extent;
Let’s analyze it from the perspective of memory. The memory is logically divided into four segments. The object is placed in the "heap memory"
, the reference of the object is placed in the "stack memory", and the static members are placed in the "initialized static segment", when the class is loaded for the first time
When placed, it can be shared by every object in the heap memory, as shown below;

=700) window.open('/upload/20090930223111418.gif');" src="http:/ /www.bkjia.com/uploads/allimg/131016/0919403415-0.gif" onload="if(this.width>'700')this.width='700';if(this.height>'700') this.height='700';" border=0>

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


Copy code

The code is as follows: ;? class Person{ //The following are the static member attributes of the personpublic static $myCountry="China"; // var $name; //The person’s name

//This is a human static member method

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 first loaded, static members can be accessed using the class
name without requiring an object outside the class; as mentioned above, static members are Shared by every instance object of this class, then
can we access static members in the 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. , static members cannot be accessed using objects. 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 Try not to use them, because the purpose of static members when working on projects is to use class names to access them.
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. If we want to use the method in this class To access other members of this class, 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 with Class name to access, so there is no object at all, and there is no $this reference. Without
, the $this reference cannot access non-static members in the class, and because static members in the class can be used Object
is accessed, so the static methods in the class can only access the static attributes of the class. Since $this does not exist, we use a special class to access other static members in the static method
." self"; self is similar to $this, except that self represents 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 code

The code is as follows:

class Person{

/ /The following are the static member attributes of people
public static $myCountry="China";
//This is the static member method of people, access other static members through self
public static function say(){
echo "I am".self::$myCountry."
";
}
}
//Access static method
Person::say();
?>


Can static members be accessed in non-static methods? Of course it is possible, but "$this" cannot be used.
References must also use class names or " self::form of member attribute".

const is a keyword for defining constants. To define constants in PHP, the "define()" function is used, but
is to define constants in a class using the "const" keyword, similar to #define in C If you change the value of
in the program, an error will occur. The access method of member attributes modified with "const" is similar to the access method of member
modified with "static". Use the "class name" and the "self" keyword in the method. But you don't need to use the "$"
symbol, nor can you use objects to access it.
Code snippet



Copy 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 the class name to access without adding "$"
$class = new MyClass();
$class ->showConstant();
// echo $class::constant; is not allowed

http://www.bkjia.com/PHPjc/320633.html

www.bkjia.comtruehttp: //www.bkjia.com/PHPjc/320633.htmlTechArticle14. Application of final keyword This keyword can only be used to define classes and methods, final cannot be used Keyword to define member properties, because final means constant, we are...