真实世界的接口实现

Question

这个问题听起来很明显，也可能是愚蠢的。但我想弄清楚为什么我需要使用接口？我认为我可以处理接口使用类的大部分事情，那么使用它们有什么意义？确实，如果我不接口，我可能会遇到问题，但我试图找出不使用接口导致的问题。

接口的一种用法是它们允许我们定义行为并对实现它们的类进行限制。

另一个用途是将接口工作为类型，我可以使用类型提示的接口，如下所示。

//Java example 
public interface IPaintable{ 
    void Paint(System.Drawing.Color color); 
} 

public void Paint(IPaintable item, System.Drawing.Color color){ 
    item.Paint(color); 
} 

但是在PHP中有没有其他使用接口？

I.e.通过使用下面的代码中的接口，我可以获得什么优势。

//Non interface implementation 
    <?php 
    class DBPersonProvider 
    { 
     public function getPerson($givenName, $familyName) 
     { 
      /* go to the database, get the person... */ 
      $person = new Person(); 
      $person->setPrefix("Mr."); 
      $person->setGivenName("John"); 
      return $person; 
     } 
    } 

    /* I need to get person data... */ 
    $provider = new DBPersonProvider(); 
    $person = $provider->getPerson("John", "Doe"); 

    echo($person->getPrefix()); 
    echo($person->getGivenName()); 

    ?> 

    //Implementation with interface 

     <?php 
     interface PersonProvider 
     { 
      public function getPerson($givenName, $familyName); 
     } 

     class DBPersonProvider implements PersonProvider 
     { 
      public function getPerson($givenName, $familyName) 
      { 
      /* pretend to go to the database, get the person... */ 
      $person = new Person(); 
      $person->setPrefix("Mr."); 
      $person->setGivenName("John"); 
      return $person; 
     } 
    } 


    /* I need to get person data... */ 
    $provider = new DBPersonProvider(); 
    $person = $provider->getPerson("John", "Doe"); 

    echo($person->getPrefix()); 
    echo($person->getGivenName()); 
    ?> 

Answer 1

我写了一个很好的库，与数据库交互。而我使用MySQL。当你购买我的图书馆时，你知道它是基于MySQL，但是你用SQL Server滚动。 我非常体贴为数据库访问创建接口。我提供了一个MySQL的实现。现在，您可以在我的数据库访问界面上实现自己的SQL Server包装，然后将其用作库中用于将存储更改为SQL Server的类中的类的__construct()参数。

接口是库/可重用的代码编写者非常有用像我 :)他们是必须要遵守的代码合同。 您知道任何实现它们的类都将具有与接口声明的完全一样的功能。你也可以在函数参数中静态地键入它们，如function(MyInterface $Object)，它在PHP编译器级别强制$Object必须实现MyInterface。

PS：抽象类是用于自写代码的开发人员耗费休息不够好...

UPDATE：

/** 
* Database Access functionality blueprint. 
*/ 
interface IDatabaseAccess { 
    public function Connect(); 
    public function Query(); 
    public function Fetch(); 
} 

/** 
* Database Access functionality implementation for MySQL. 
*/ 
class MySqlDatabaseAccess implements IDatabaseAccess { 
    public function Query(){ 
     // do mysql stuff 
    } 
    public function Fetch(){ 
     // do mysql stuff 
    } 
} 

/** 
* Database Access functionality implementation for SQLServer. 
*/ 
class SqlServerDatabaseAccess implements IDatabaseAccess { 
    public function Query(){ 
     // do sqlserver stuff 
    } 
    public function Fetch(){ 
     // do sqlserver stuff 
    } 
} 

/** 
* Database Access consumer that's database system agnostic. 
*/ 
class DatabaseAccessConsumer { 
    protected $_Provider = null; 
    public function __construct(IDatabaseAccess $Provider){ 
     $this->_Provider = $Provider; 
     $this->_Provider->Connect(); 
    } 
    public function Query(){ 
     return $this->_Provider->Query(); 
    } 
    public function Fetch(){ 
     return $this->_Provider->Fetch(); 
    } 
} 

^代码，应该讲本身。

Answer 2

接口实际上比抽象类提供更少的功能（你不能实现任何东西）。

但他们解决了多重继承的问题。大多数现代语言不允许一个班级派生多个班级。通过使用一个没有实现任何方法的接口，当你从接口调用一个方法时（因为没有实现），你肯定没有不明确之处。

示例（语法上无效）：

class A { 
    public foo() { 
     echo 'I am A and I foo'; 
    }; 
    public 
} 

class B { 
    public foo() { 
     echo 'I am B and I foo'; 
    } 
} 

class C extends A, B { // invalid 
    public bar() { 
     foo(); // which one? A's or B's? 
    } 
} 

第二个例子：

class A { 
    public foo() { 
     echo 'I am A and I foo'; 
    }; 
} 

interface iB { 
    public foo(); 
    public bar(); 
} 

interface iC { 
    public foo(); 
    public qux(); 
} 

class D extends A implements iB, iC { 

    public bar() { 
     foo(); // no ambiguity, this is A::foo(), even if the method is also declared in the interfaces 
    } 

    public qux() {} 
} 

Answer 3

接口都只是类蓝图 - 他们说：“如果你打算做什么用的方式这种班级，它必须有这个，并做到这一点。“它允许您在某种程度上控制另一个班级在特定情况下的最小程度。并非每种情况都需要一个iterface。当需要对某些类的基本代码进行一些控制时，最好使用接口，但您可能不是编写它们的人。如果你知道扩展类将有x属性和y方法，那么你可以做基本的未来类支持。