Class Abstraction -- Object Interfaces

  1 php
  2 /*
  3 PHP 5 introduces abstract classes and methods. Classes defined as abstract may not be instantiated, and any class that contains at least one abstract method must also be abstract. Methods defined as abstract simply declare the method's signature - they cannot define the implementation. 
  4 
  5 PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。 
  6 
  7 When inheriting from an abstract class, all methods marked abstract in the parent's class declaration must be defined by the child; additionally, these methods must be defined with the same (or a less restricted) visibility. For example, if the abstract method is defined as protected, the function implementation must be defined as either protected or public, but not private. Furthermore the signatures of the methods must match, i.e. the type hints and the number of required arguments must be the same. For example, if the child class defines an optional argument, where the abstract method's signature does not, there is no conflict in the signature. This also applies to constructors as of PHP 5.4. Before 5.4 constructor signatures could differ.
  8 继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。此外方法的调用方式必须匹配，即类型和所需参数数量必须一致。例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则两者的声明并无冲突。 这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的。 
  9 
 10 */
 11 
 12 abstract class AbstractClass
 13 {
 14     //Force Extending class to define this method
 15     // 强制要求子类定义这些方法
 16     abstract protected function getValue();
 17     abstract protected function prefixValue($prefix);
 18 
 19     // Common method 普通方法（非抽象方法）
 20     public function printOut(){
 21         print $this->getValue().'
';
 22     }
 23 }
 24 
 25 class ConcreteClass1 extends AbstractClass
 26 {
 27     protected function getValue(){
 28         return 'ConcreteClass1';
 29     }
 30 
 31     public function prefixValue($prefix){
 32         return "{$prefix}".'ConcreteClass1';
 33     }
 34 }
 35 
 36 class ConcreteClass2 extends AbstractClass
 37 {
 38     public function getValue(){
 39         return 'ConcreteClass2';
 40     }
 41 
 42     public function prefixValue($prefix){
 43         return "{$prefix}".'ConcreteClass2';
 44     }
 45 }
 46 
 47 /*
 48 class ConcreteClass3 extends AbstractClass
 49 {
 50     private function getValue(){
 51         return 'ConcreteClass3';
 52     }//Fatal error: Access level to ConcreteClass3::getValue() must be protected (as in class AbstractClass) or weaker in 
 53 
 54     public function prefixValue($prefix){
 55         return "{$prefix}".'ConcreteClass3';
 56     }
 57 }
 58 */
 59 
 60 
 61 $class1 = new ConcreteClass1;
 62 $class1->printOut();
 63 echo $class1->prefixValue('FOO_').'
';
 64 
 65 $class2 = new ConcreteClass2;
 66 $class2->printOut();
 67 echo $class2->prefixValue('FOO_').'
';
 68 
 69  
 70 
 71 abstract class AbstractClassB
 72 {
 73     // Our abstract method only needs to define the required arguments
 74     // 我们的抽象方法仅需要定义需要的参数
 75     abstract protected function prefixNameB($name);
 76 }
 77 
 78 class ConcreteClassB extends AbstractClassB
 79 {
 80     // Our child class may define optional arguments not in the parent's signature
 81     // 我们的子类可以定义父类签名中不存在的可选参数
 82     public function prefixNameB($name, $separator = '.'){
 83         if ($name == 'Pacman') {
 84             $prefix = 'Mr';
 85         } elseif ($name == 'Pacwoman') {
 86             $prefix = 'Mrs';
 87         } else {
 88             $prefix = '';
 89         }
 90         return "{$prefix}{$separator} {$name}";
 91     }
 92 }
 93 
 94 $classB = new ConcreteClassB;
 95 echo $classB->prefixNameB('Pacman'), '
';
 96 echo $classB->prefixNameB('Pacwoman'), '
';
 97 
 98 
 99 /*
100 Object Interfaces 
101 Object interfaces allow you to create code which specifies which methods a class must implement, without having to define how these methods are handled. 
102 Interfaces are defined in the same was as a class, but with the interface keyword replacing the class keyword and without any of the methods having their contents defined. 
103 All methods declared in an interface must be public; this is the nature of an interface. 
104 对象接口 
105 使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。 
106 接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。 
107 接口中定义的所有方法都必须是公有，这是接口的特性。 
108 
109 
110 
111 
112 implements 
113 To implement an interface, the implements operator is used. All methods in the interface must be implemented within a class; failure to do so will result in a fatal error. Classes may implement more than one interface if desired by separating each interface with a comma. 
114 Note: 
115 Prior to PHP 5.3.9, a class could not implement two interfaces that specified a method with the same name, since it would cause ambiguity. More recent versions of PHP allow this as long as the duplicate methods have the same signature. 
116 Note: 
117 Interfaces can be extended like classes using the extends operator. 
118 Note: 
119 The class implementing the interface must use the exact same method signatures as are defined in the interface. Not doing so will result in a fatal error. 
120 Constants 
121 It's possible for interfaces to have constants. Interface constants works exactly like class constants except they cannot be overridden by a class/interface that inherits them. 
122 实现（implements） 
123 要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。 
124 Note: 
125 实现多个接口时，接口中的方法不能有重名。 
126 Note: 
127 接口也可以继承，通过使用 extends 操作符。 
128 Note: 
129 类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。 
130 常量 
131 接口中也可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。 
132 
133 
134 */
135 
136 // Declare the interface 'iTemplate'
137 interface iTemplate
138 {
139     public function setVariable($name, $var);
140     public function getHtml($template);
141 }
142 
143 // Implement the interface
144 // This will work
145 
146 class Template implements iTemplate
147 {
148     private $vars = array();
149 
150     public function setVariable($name, $var)
151     {
152         $this->vars[$name] = $var;
153     }
154 
155     public function getHtml($template)
156     {
157         foreach ($this->vars as $name => $value) {
158             $template = str_replace('{'.$name.'}', $value, $template);
159         }
160         return $template;
161     }
162 }
163 
164 /*
165 class BadTemplate implements iTemplate
166 {
167     private $var = array();
168     public function setVariable($name, $var)
169     {
170         $this->vars[$name] = $var;
171     }
172 }
173 Fatal error: Class BadTemplate contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (iTemplate::getHtml) 
174 
175 */
176 
177 /*
178 class BadTemplate implements iTemplate
179 {
180     private $vars = array();
181 
182     public function setVariable($name, $var,$echo)
183     {
184         //Fatal error: Declaration of BadTemplate::setVariable() must be compatible with iTemplate::setVariable($name, $var)
185 
186         $this->vars[$name] = $var;
187         echo $echo;
188     }
189 
190     public function getHtml($template)
191     {
192         foreach ($this->vars as $name => $value) {
193             $template = str_replace('{'.$name.'}', $value, $template);
194         }
195         return $template;
196     }
197 }
198 */
199 
200 /*
201 class BadTemplate implements iTemplate
202 {
203     private $vars = array();
204 
205     // Fatal error: Access level to BadTemplate::setVariable() must be public (as in class iTemplate)
206 
207     protected function setVariable($name, $var)
208     {
209         
210         $this->vars[$name] = $var;
211     }
212 
213     public function getHtml($template)
214     {
215         foreach ($this->vars as $name => $value) {
216             $template = str_replace('{'.$name.'}', $value, $template);
217         }
218         return $template;
219     }
220 }
221 
222 */
223 
224 
225 
226 interface a
227 {
228     public function foo();
229 }
230 
231 interface b extends a 
232 {
233     public function baz(Baz $baz);
234 }
235 
236 class c implements b
237 {
238     public function foo()
239     {
240 
241     }
242 
243     public function baz(Baz $baz)
244     {
245 
246     }
247 }
248 
249 /*
250 Fatal error: Declaration of d::baz() must be compatible with b::baz(Baz $baz)
251 
252 class d implements b
253 {
254     public function foo()
255     {
256 
257     }
258 
259     public function baz(Foo $foo)
260     {
261 
262     }
263 }
264 */
265 
266 
267 //Multiple interface inheritance 继承多个接口
268 
269 interface a1 
270 {
271     public function foo();
272 }
273 
274 interface b1
275 {
276     public function bar();
277 }
278 
279 interface c1 extends a1, b1
280 {
281     public function baz();
282 }
283 
284 class d1 implements c1
285 {
286     public function foo()
287     {
288     }
289 
290     public function bar()
291     {
292     }
293 
294     public function baz()
295     {
296     }
297 }
298 
299 //Interfaces with constants 使用接口常量
300 interface a2
301 {
302     const b2 = 'Interface constant';
303 }
304 
305 echo a2::b2;
306 
307 /*
308  Fatal error: Cannot inherit previously-inherited or override constant b2 from interface a2 
309  错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
310 
311 class c2 implements a2
312 {
313     const  b2 ='Class constant';
314 }
315 
316 */

http://php.net/

小结：

0-子类需定义抽象类所有方法，方法参数个数可以添加，访问控制同或弱，而对象接口的实现也需要实现全部方法，但是参数个数不可更改，且访问控制必须public。

发问：

0-框架中的实例？