$ This, static, final, const, and self usage in php

This article mainly describes how to use the $ this, static, final, const, and self keywords in the php class. $ This indicates that the current instance is accessed through internal methods of the class.

This article mainly describes how to use the $ this, static, final, const, and self keywords in the php class.

$ This

$ This indicates the current instance. when the internal method access of the class is not declared as a const or static attribute, $ this-> value = 'phpernote'; is used. Common usage:

$ This-> attribute

$ This-> method

The instance code is as follows:

2. Class MyClass {
3. Private $ name;
4. Public function _ construct ($ name ){
5. $ This-> name = $ name;
6. }
7. Public function getname (){
8. Return $ this-> name;
9. }
10. Public function printName (){
11. Echo $ this-> getname ();
12. }
13. }
14. $ Myclass = new MyClass ("I Like www.111cn.net ");
15. $ Myclass-> printName (); // output: I Like www.111cn.net
16. ?>

There are three methods to call the attributes and methods of the current class in the class: self, parent, and $ this. The difference between the three keywords is: self is used to direct to the current class; parent is used to point to the parent class of the current class. you can use this keyword to call the attributes and methods of the parent class. $ this is used to call its own attributes and methods in the class body.

Static

The keyword can be self (used when a static member is called within the class) the class name of the static member (used when a static member inside the class is called outside the class)

Declare a static variable as follows:

Static $ val = '';

Variables only exist in the function scope. after the function is executed, the value of the variable will not be lost and will only be initialized once. the expression cannot be used to initialize static variables, you do not need to replace global variables because they are easily accessed by all functions and thus are not suitable for maintenance.

Using static in a class has two main purposes: defining static members and defining static methods. Static members only keep the value of one variable. this value is valid for all instances. the code is as follows:

2. Class MyObject {
3. Public static $ myStaticVar = 0;
4. Function myMethod (){
5. Self: $ myStaticVar + = 2;
6. Echo self: $ myStaticVar;
7. }
8. }
9. $ Instance1 = new MyObject ();
10. $ Instance1-> myMethod ();
11. $ Instance2 = new MyObject ();
12. $ Instance2-> myMethod ();
13. // The result is printed 2 and 4 respectively.

The instance code is as follows:

2. Class Book {
3. Static $ num = 0;
4. Public function showMe (){
5. Echo "you are a drop". self: $ num. "guest ";
6. Self: $ num ++;
7. }
8. }
9. $ Book1 = new Book ();
10. $ Book1-> showMe ();
11. Echo"
    ";
12. $ Book2 = new Book ();
13. $ Book2-> showMe ();
14. Echo"
    ";
15. Echo "you are a drop". Book: $ num. "guest ";
16. ?>
17. // The result will be:
18. // You are a visitor of 0
19. // You are a visitor
20. // You are two visitors

In addition, it should be noted that if the class method is static, the Accessed attribute must also be static.

Final

PHP final keywords can modify classes and methods in classes, but they have similar functions, that is, if you use final keywords to modify them, the modified class or method cannot be extended or inherited. You can only honestly reference it. If you use final before the class, this indicates that this class cannot use inheritance. if you use the PHP final keyword before the method, this indicates that this method cannot be overwritten. The truth is that simple. let's take a look at a simple example.

The final class and method cannot be inherited, and the method modified by this keyword cannot be overwritten. The general usage is as follows:

2. Final class MyClass {// This class cannot be inherited
3. Final function fun1 () {...} // this method will not be allowed to be overwritten
4. }

The instance code is as follows:

2. Final class BaseClass {
3. Public function test (){
4. Echo "BaseClass: test () calledn ";
5. }
6. Final public function moreTesting (){
7. Echo "BaseClass: moreTesting () calledn ";
8. }
9. }
10. Class ChildClass extends BaseClass {
11. Public function moreTesting (){
12. Echo "ChildClass: moreTesting () calledn ";
13. }
14. }
15. // Results in Fatal error: Cannot override final method BaseClass: moreTesting ()
16. ?>

Const

When you access the attributes declared as const and static by using the internal method of the class, you must use the self ::$ name method. the instance code is as follows:

2. Class clss_a {
3. Private static $ name = "static class_a ";
4. Const PI = 3.14;
5. Public $ value;
6. Public static function getName (){
7. Return self: $ name;
8. }
9. // This statement is incorrect. the static method cannot access non-static attributes.
10. Public static function getName2 (){
11. Return self: $ value;
12. }
13. Public function getPI (){
14. Return self: PI;
15. }
16. }

Note that the declarative format of the const attribute is const PI = 3.14, rather than const $ PI = 3.14.

Self

Self indicates the class itself, pointing to the current class. It is usually used for static members, methods, and constants of the category class.