PHP中static::与new static()之后期静态绑定

一、parent、self、$this、__CLASS__

1. class A {} 
2.  
3. class B extends A{ 
4.  
5. parent::(public|protected)(静态方法|静态变量)  ===> parent永远是A 
6.  
7. self::(public|protected)(静态方法|静态变量)  ===> self永远是B 
8.  
9. $this->(public|protected)(非静态方法|非静态变量)  ===> $this永远是B的是实例化对象 
10.  
11. __CLASS__    ===> 永远是B 
12.  
13. }  
14.  
15. class C extends B{ 
16.  
17. parent::(public|protected)(静态方法|静态变量)  ===> parent永远是B 
18.  
19. self::(public|protected)(静态方法|静态变量)  ===> self永远是C 
20.  
21. $this->(public|protected)(非静态方法|非静态变量)  ===> $this永远是C的是实例化对象 
22.  
23. __CLASS__    ===> 永远是C  
24.  
25. } 

二、static::

static关键字可以实现以下功能：

1 调用类的静态方法 有后期静态绑定效果；

2 调用类的静态属性 有后期静态绑定效果；

3 调用类的非静态方法 没有后期静态绑定效果；

4 注意：不可以调用非静态属性；

1. class A { 
2.  
3.     private static function foo() { 
4.  
5.         echo "A success!\n"; 
6.  
7.     } 
8.  
9.     public function test() { 
10.  
11.          $this->foo(); 
12.  
13.     } 
14.  
15. } 
16.  
17.    
18.  
19. class B extends A { 
20.  
21. } 
22.  
23.    
24.  
25. class C extends A { 
26.  
27.     private static function foo() { 
28.  
29.     echo "C success!\n"; 
30.  
31.     } 
32.  
33. } 
34.  
35.    
36.  
37. $b = new B(); 
38.  
39. $b->test();//A success! 
40.  
41. $c = new C(); 
42.  
43. $c->test();//A success! 
44.  
45. class A { 
46.  
47.     private static function foo() { 
48.  
49.         echo "A success!\n"; 
50.  
51.     } 
52.  
53.     public function test() { 
54.  
55.         static::foo(); 
56.  
57.     } 
58.  
59. } 
60.  
61.    
62.  
63. class B extends A { 
64.  
65. } 
66.  
67.    
68.  
69. class C extends A { 
70.  
71.     private static function foo() { 
72.  
73.     echo "C success!\n"; 
74.  
75.     } 
76.  
77. } 
78.  
79.    
80.  
81. $b = new B(); 
82.  
83. $b->test();//A success! 
84.  
85. $c = new C(); 
86.  
87. $c->test();//A无法调用C里的私有foo方法  
88.  
89. //将C的foo改成非private(public|protected)就可以解决 
90.  
91. class A { 
92.  
93.     private static function foo() { 
94.  
95.         echo "A success!\n"; 
96.  
97.     } 
98.  
99.     public function test() { 
100.  
101.         static::foo(); 
102.  
103.     } 
104.  
105. } 
106.  
107.    
108.  
109. class B extends A { 
110.  
111. } 
112.  
113.    
114.  
115. class C extends A { 
116.  
117.     public static function foo() { 
118.  
119.     echo "C success!\n"; 
120.  
121.     } 
122.  
123. } 
124.  
125.    
126.  
127. $b = new B(); 
128.  
129. $b->test();//A success! 
130.  
131. $c = new C(); 
132.  
133. $c->test();//C success! 
134.  
135.  
136. class A { 
137.  
138.  public static function foo() { 
139.  
140.      static::who(); 
141.  
142.  } 
143.  
144.    
145.  
146.  public static function who() { 
147.  
148.      echo __CLASS__."\n"; 
149.  
150.  } 
151.  
152. } 
153.  
154.    
155.  
156. class B extends A { 
157.  
158.  public static function test() { 
159.  
160.      A::foo(); 
161.  
162.      parent::foo(); 
163.  
164.      self::foo(); 
165.  
166.  } 
167.  
168.    
169.  
170.  public static function who() { 
171.  
172.      echo __CLASS__."\n"; 
173.  
174.  } 
175.  
176. } 
177.  
178. class C extends B { 
179.  
180.  public static function who() { 
181.  
182.      echo __CLASS__."\n"; 
183.  
184.  }  
185.  
186. } 
187.  
188. C::test();  

A =>A::foo()的结果

C =>parent::foo()能走到A的foo,里面static::who找C::who

C =>self::foo()能走到B的foo,B继承A,走到A的foo,里面static::who找C::who

1. class A { 
2.  
3.     protected static function foo() { 
4.  
5.         static::who(); 
6.  
7.     } 
8.  
9.    
10.  
11.     protected static function who() { 
12.  
13.         echo __CLASS__."\n"; 
14.  
15.     } 
16.  
17. } 
18.  
19.    
20.  
21. class B extends A { 
22.  
23.     public static function test() { 
24.  
25.         A::foo(); 
26.  
27.         parent::foo(); 
28.  
29.         self::foo(); 
30.  
31.     } 
32.  
33.    
34.  
35.     protected static function who() { 
36.  
37.         echo __CLASS__."\n"; 
38.  
39.     } 
40.  
41. } 
42.  
43. class C extends B { 
44.  
45.     protected static function who() { 
46.  
47.         echo __CLASS__."\n"; 
48.  
49.     }  
50.  
51. } 
52.  
53.    
54.  
55. C::test(); //A C C,解释同上 
56.  
57.  
58. class A { 
59.  
60.  public static function foo() { 
61.  
62.      static::who(); 
63.  
64.  } 
65.  
66.    
67.  
68.  private static function who() { 
69.  
70.      echo __CLASS__."\n"; 
71.  
72.  } 
73.  
74. } 
75.  
76.    
77.  
78. class B extends A { 
79.  
80.  public static function test() { 
81.  
82.      A::foo(); 
83.  
84.      parent::foo(); 
85.  
86.      // self::foo();   
87.  
88.  } 
89.  
90.    
91.  
92.  private static function who() { 
93.  
94.      echo __CLASS__."\n"; 
95.  
96.  } 
97.  
98. } 
99.  
100. class C extends B { 
101.  
102.  private static function who() { 
103.  
104.      echo __CLASS__."\n"; 
105.  
106.  }  
107.  
108. } 
109.  
110.    
111.  
112. C::test(); 
113.  
114. //A =>A::foo()的结果  
115.  
116. //报错 A不可C的私有方法who => parent::foo()能走到A的foo,里面static::who找C::who,C的who只能在C里调用，不能在A里调用 
117.  
118. //报错 A不可C的私有方法who => self::foo()能走到B的foo,B继承A,走到A的foo,里面static::who找C::who,C的who只能在C里调用，不能在A里调用 

三、new static()

1. //new self()与new static()的区别，官网例子如下：  
2.  
3. class A { 
4.  
5.   public static function get_self() { 
6.  
7.     return new self(); 
8.  
9.   } 
10.  
11.   public static function get_static() { 
12.  
13.     return new static(); 
14.  
15.   } 
16.  
17. } 
18.  
19. class B extends A {} 
20.  
21. echo get_class(B::get_self()); // A 
22.  
23. echo get_class(B::get_static()); // B 
24.  
25. echo get_class(A::get_static()); // A

Tags: static:: new static()

分享到：