Class Abstraction -- Object Interfaces

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().'<br>';
 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_').'<br>';
 64 
 65 $class2 = new ConcreteClass2;
 66 $class2->printOut();
 67 echo $class2->prefixValue('FOO_').'<br>';
 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'), '<br>';
 96 echo $classB->prefixNameB('Pacwoman'), '<br>';
 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/