下面是PHP接口的要点

It is used to define required no of methods in class [if you want to load html then id and name is required so in this case interface include setID and setName]. Interface strictly force class to include all the methods define in it. You can only define method in interface with public accessibility. You can also extend interface like class. You can extend interface in php using extends keyword. Extend multiple interface. You can not implement 2 interfaces if both share function with same name. It will throw error.

示例代码:

interface test{
    public function A($i);
    public function B($j = 20);
}

class xyz implements test{
    public function A($a){
        echo "CLASS A Value is ".$a;
    }
    public function B($b){
        echo "CLASS B Value is ".$b;
    }
}
$x = new xyz();
echo $x->A(11);
echo "<br/>";
echo $x->B(10);

对我来说，使用接口和抽象类之间的区别更多地与代码组织有关，而不是由语言本身强制执行。在为其他开发人员准备代码时，我经常使用它们，以便它们保持在预期的设计模式内。接口是一种“契约式设计”，您的代码同意响应一组规定的API调用，这些API调用可能来自您没有访问权限的代码。

虽然从抽象类继承是一个“是一个”关系，但这并不总是你想要的，实现接口更像是一个“像一个”关系。在某些情况下，这种差异可能相当显著。

例如，假设您有一个抽象类Account，许多其他类都是从这个抽象类扩展而来的(Account的类型等等)。它有一组特定的方法，只适用于该类型组。但是，这些帐户子类中的一些实现了Versionable、Listable或Editable，以便它们可以被扔到期望使用这些api的控制器中。控制器并不关心对象的类型

相比之下，我还可以创建一个不从Account扩展的对象，比如User抽象类，仍然实现Listable和Editable，但不实现Versionable，这在这里没有意义。

通过这种方式，我说FooUser子类不是一个帐户，但确实像一个可编辑对象。同样，BarAccount从Account扩展而来，但不是User子类，而是实现了可编辑、可列表和可版本。

将所有这些可编辑的、可列表的和可版本的api添加到抽象类本身不仅是混乱和丑陋的，而且会重复Account和User中的公共接口，或者强制我的User对象实现Versionable，可能只是抛出一个异常。

下面是PHP接口的要点

It is used to define required no of methods in class [if you want to load html then id and name is required so in this case interface include setID and setName]. Interface strictly force class to include all the methods define in it. You can only define method in interface with public accessibility. You can also extend interface like class. You can extend interface in php using extends keyword. Extend multiple interface. You can not implement 2 interfaces if both share function with same name. It will throw error.

示例代码:

interface test{
    public function A($i);
    public function B($j = 20);
}

class xyz implements test{
    public function A($a){
        echo "CLASS A Value is ".$a;
    }
    public function B($b){
        echo "CLASS B Value is ".$b;
    }
}
$x = new xyz();
echo $x->A(11);
echo "<br/>";
echo $x->B(10);

界面就像你的基因。

抽象类就像你实际的父母。

它们的目的是遗传的，但是在抽象类和接口的情况下，继承的是更具体的。

我不了解其他语言，界面的概念是什么。但对于PHP，我将尽力解释。耐心点，如果有帮助请评论。

接口就像“契约”一样工作，指定一组子类做什么，但不指定它们如何做。

规则

An Interface can't be instantiate. You can't implement any method in an interface,i.e. it only contains .signature of the method but not details(body). Interfaces can contain methods and/or constants, but no attributes. Interface constants have the same restrictions as class constants. Interface methods are implicitly abstract. Interfaces must not declare constructors or destructors, since these are implementation details on the class level. All the methods in an interface must have public visibility.

现在让我们举个例子。 假设我们有两个玩具:一个是狗，另一个是猫。

正如我们所知，狗叫，猫叫。这两者具有相同的说话方法，但具有不同的功能或实现。 假设我们给用户一个带有说话按钮的遥控器。

当用户按下说话按钮时，玩具必须说话，无论它是狗还是猫。

这是使用接口而不是抽象类的好情况，因为实现是不同的。 为什么?还记得

如果您需要通过添加一些非抽象方法来支持子类，则应该使用抽象类。否则，接口将是您的选择。

接口不会给您的代码带来任何性能提升或类似的东西，但它们可以使代码更易于维护。的确，抽象类(甚至非抽象类)可以用来建立到代码的接口，但是适当的接口(用关键字定义并且只包含方法签名的接口)更容易排序和读取。

话虽如此，在决定是否使用接口而不是类时，我倾向于谨慎。有时我想要默认的方法实现，或者所有子类都通用的变量。

当然，关于多接口实现的观点也是合理的。如果您有一个实现多个接口的类，您可以在同一个应用程序中使用该类的对象作为不同的类型。

The fact that your question is about PHP, though, makes things a bit more interesting. Typing to interfaces is still not incredibly necessary in PHP, where you can pretty much feed anything to any method, regardless of its type. You can statically type method parameters, but some of that is broken (String, I believe, causes some hiccups). Couple this with the fact that you can't type most other references, and there isn't much value in trying to force static typing in PHP (at this point). And because of that, the value of interfaces in PHP, at this point is far less than it is in more strongly-typed languages. They have the benefit of readability, but little else. Multiple-implementation isn't even beneficial, because you still have to declare the methods and give them bodies within the implementor.