Class Abstraction -- Object Interfaces

 <?php
 /*
 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. 
 
 PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。 
 
 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.
 继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。此外方法的调用方式必须匹配，即类型和所需参数数量必须一致。例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则两者的声明并无冲突。 这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的。 
 
 */
 
 abstract class AbstractClass
 {
     //Force Extending class to define this method
     // 强制要求子类定义这些方法
     abstract protected function getValue();
     abstract protected function prefixValue($prefix);
 
     // Common method 普通方法（非抽象方法）
     public function printOut(){
         print $this->getValue().'<br>';
     }
 }
 
 class ConcreteClass1 extends AbstractClass
 {
     protected function getValue(){
         return 'ConcreteClass1';
     }
 
     public function prefixValue($prefix){
         return "{$prefix}".'ConcreteClass1';
     }
 }
 
 class ConcreteClass2 extends AbstractClass
 {
     public function getValue(){
         return 'ConcreteClass2';
     }
 
     public function prefixValue($prefix){
         return "{$prefix}".'ConcreteClass2';
     }
 }
 
 /*
 class ConcreteClass3 extends AbstractClass
 {
     private function getValue(){
         return 'ConcreteClass3';
     }//Fatal error: Access level to ConcreteClass3::getValue() must be protected (as in class AbstractClass) or weaker in 
 
     public function prefixValue($prefix){
         return "{$prefix}".'ConcreteClass3';
     }
 }
 */
 
 $class1 = new ConcreteClass1;
 $class1->printOut();
 echo $class1->prefixValue('FOO_').'<br>';
 
 $class2 = new ConcreteClass2;
 $class2->printOut();
 echo $class2->prefixValue('FOO_').'<br>';
 
 abstract class AbstractClassB
 {
     // Our abstract method only needs to define the required arguments
     // 我们的抽象方法仅需要定义需要的参数
     abstract protected function prefixNameB($name);
 }
 
 class ConcreteClassB extends AbstractClassB
 {
     // Our child class may define optional arguments not in the parent's signature
     // 我们的子类可以定义父类签名中不存在的可选参数
     public function prefixNameB($name, $separator = '.'){
         if ($name == 'Pacman') {
             $prefix = 'Mr';
         } elseif ($name == 'Pacwoman') {
             $prefix = 'Mrs';
         } else {
             $prefix = '';
         }
         return "{$prefix}{$separator} {$name}";
     }
 }
 
 $classB = new ConcreteClassB;
 echo $classB->prefixNameB('Pacman'), '<br>';
 echo $classB->prefixNameB('Pacwoman'), '<br>';
 
 /*
 Object Interfaces
 Object interfaces allow you to create code which specifies which methods a class must implement, without having to define how these methods are handled.
 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.
 All methods declared in an interface must be public; this is the nature of an interface.
 对象接口
 使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
 接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
 接口中定义的所有方法都必须是公有，这是接口的特性。 
 
 implements
 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.
 Note:
 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.
 Note:
 Interfaces can be extended like classes using the extends operator.
 Note:
 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.
 Constants
 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.
 实现（implements）
 要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
 Note:
 实现多个接口时，接口中的方法不能有重名。
 Note:
 接口也可以继承，通过使用 extends 操作符。
 Note:
 类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。
 常量
 接口中也可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。 
 
 */
 
 // Declare the interface 'iTemplate'
 interface iTemplate
 {
     public function setVariable($name, $var);
     public function getHtml($template);
 }
 
 // Implement the interface
 // This will work
 
 class Template implements iTemplate
 {
     private $vars = array();
 
     public function setVariable($name, $var)
     {
         $this->vars[$name] = $var;
     }
 
     public function getHtml($template)
     {
         foreach ($this->vars as $name => $value) {
             $template = str_replace('{'.$name.'}', $value, $template);
         }
         return $template;
     }
 }
 
 /*
 class BadTemplate implements iTemplate
 {
     private $var = array();
     public function setVariable($name, $var)
     {
         $this->vars[$name] = $var;
     }
 }
 Fatal error: Class BadTemplate contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (iTemplate::getHtml) 
 
 */
 
 /*
 class BadTemplate implements iTemplate
 {
     private $vars = array();
 
     public function setVariable($name, $var,$echo)
     {
         //Fatal error: Declaration of BadTemplate::setVariable() must be compatible with iTemplate::setVariable($name, $var)
 
         $this->vars[$name] = $var;
         echo $echo;
     }
 
     public function getHtml($template)
     {
         foreach ($this->vars as $name => $value) {
             $template = str_replace('{'.$name.'}', $value, $template);
         }
         return $template;
     }
 }
 */
 
 /*
 class BadTemplate implements iTemplate
 {
     private $vars = array();
 
     // Fatal error: Access level to BadTemplate::setVariable() must be public (as in class iTemplate)
 
     protected function setVariable($name, $var)
     {
 
         $this->vars[$name] = $var;
     }
 
     public function getHtml($template)
     {
         foreach ($this->vars as $name => $value) {
             $template = str_replace('{'.$name.'}', $value, $template);
         }
         return $template;
     }
 }
 
 */
 
 interface a
 {
     public function foo();
 }
 
 interface b extends a
 {
     public function baz(Baz $baz);
 }
 
 class c implements b
 {
     public function foo()
     {
 
     }
 
     public function baz(Baz $baz)
     {
 
     }
 }
 
 /*
 Fatal error: Declaration of d::baz() must be compatible with b::baz(Baz $baz)
 
 class d implements b
 {
     public function foo()
     {
 
     }
 
     public function baz(Foo $foo)
     {
 
     }
 }
 */
 
 //Multiple interface inheritance 继承多个接口
 
 interface a1
 {
     public function foo();
 }
 
 interface b1
 {
     public function bar();
 }
 
 interface c1 extends a1, b1
 {
     public function baz();
 }
 
 class d1 implements c1
 {
     public function foo()
     {
     }
 
     public function bar()
     {
     }
 
     public function baz()
     {
     }
 }
 
 //Interfaces with constants 使用接口常量
 interface a2
 {
     const b2 = 'Interface constant';
 }
 
 echo a2::b2;
 
 /*
  Fatal error: Cannot inherit previously-inherited or override constant b2 from interface a2
  错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
 
 class c2 implements a2
 {
     const  b2 ='Class constant';
 }
 
 */

http://php.net/

小结：

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

发问：

0-框架中的实例？

//2016/8/29-9:11

Abstract Class vs. Interface

The difference between an interface and an abstract class may seem subtle. Remember that an abstract class is meant to be extended by a more specific class, of which you’ll probably create an object instance. As you’ve already seen, an abstract class might define a generic object, such as a shape.

Conversely, an interface is not inherited by a class, so you should not think of an interface as a way of loosely defining an entire object. Instead, an interface establishes a contract for the functionality that a class must have, regardless of the class type. For

example, in Chapter 8, “Using Existing Classes,” you’ll learn about the Iterator interface defined within the Standard PHP Library (SPL). The Iterator interface dictates the methods that must exist in a class in order for PHP to be able to loop through an

instance of that class.

Another way of distinguishing between abstract classes and interfaces is that abstract classes still have an “is a” relationship with the derived class. Interfaces do not have “is a” relationships with derived classes, although you could say that the derived class has a “has the same behaviors as” relationship with an interface.

In the next example, let’s create an interface for standard CRUD

functionality. The acronym CRUD refers to the ability to Create, Read, Update, and Delete data—the four basic actions required for many different types of content used in sites and applications.

Any class you use in an application that requires CRUD functionality could then implement this interface, whether it’s a User,Page, or Rectangle.

 

//一个抽象类会被扩展成一个特定的类，抽象类和它的继承类之间有一种“是一个”的关系，而接口是不同类的合约，‘契约’。

// 建立动物的抽象类，它的继承类都是动物而不能是植物；建立‘死亡’的接口，它的继承类既可以是动物也可以是植物，但必须执行‘死亡’方法。

 

 

Programming by Contract
In simple terms, programming by contract is the practice of declaring an interface before writing a class. This can be particularly useful for guaranteeing the encapsulation of your classes.Using the programming by contract technique, you will be able to identify the capabilities you are trying to implement before building your application, much in the same way an architect creates plans for a building before it is constructed.
Development teams frequently program by contract because of the many workflow improvements this technique brings. By defining the interaction of classes before any implementation begins, the team members know exactly what their objects must do; it is then fairly trivial to implement the required methods. When the interface is fully implemented, testing of the class will be conducted using only the rules defined in the interface.In the car example you’ve seen in previous sections, the ISpeedInfo interface could be considered a contract, as it is the only point of API interaction of which either class, Car or Street, needs to be aware. The Street class will test for this contract before accepting the object for interaction. One developer could then be assigned to create a Car class and another to create a Street class, and the two would not need to collaborate on the implementation beyond the IStreetInfo interface.

契约式编程