Java中的接口是什么？

接口是抽象类的一种特殊形式，它不实现任何方法。在Java中，您可以创建如下接口：

interface Interface
{
    void interfaceMethod();
}

由于接口不能实现任何方法，因此这意味着整个事物（包括所有方法）都是公共的和抽象的（抽象在Java术语中意味着“不是由这个类实现的”）。所以上面的界面和下面的界面是一样的：

public interface Interface
{
    abstract public void interfaceMethod();
}

要使用此接口，您只需实现该接口。许多类可以实现一个接口，一个类可以实现许多接口：

interface InterfaceA
{
     void interfaceMethodA();
}

interface InterfaceB
{
    void interfaceMethodB();
}

public class ImplementingClassA
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
        System.out.println("interfaceA, interfaceMethodA, implementation A");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation A");
    }
}

public class ImplementingClassB
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
         System.out.println("interfaceA, interfaceMethodA, implementation B");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation B");
    }
}

现在，如果你愿意，你可以写一个这样的方法：

public void testInterfaces()
{
    ImplementingClassA u = new ImplementingClassA();
    ImplementingClassB v = new ImplementingClassB();
    InterfaceA w = new ImplementingClassA();
    InterfaceA x = new ImplementingClassB();
    InterfaceB y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    u.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    u.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    v.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    v.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
    w.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    x.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    y.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    z.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
}

但是，您永远不能执行以下操作：

public void testInterfaces()
{
    InterfaceA y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    y.interfaceMethodB(); // ERROR!
    z.interfaceMethodA(); // ERROR!
}

您不能这样做的原因是 类型 ，并且没有。同样，是 类型，并且没有 。yinterfaceAinterfaceMethodB()interfaceAzinterfaceBinterfaceMethodA()interfaceB

我之前提到过，接口只是抽象类的一种特殊形式。为了说明这一点，请查看以下代码。

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
{
    abstract public void abstractMethod();
}

您将以几乎完全相同的方式从这些类继承：

public class InheritsFromInterface
    implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

public class InteritsFromAbstractClass
    extends AbstractClass
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

实际上，您甚至可以像这样更改接口和抽象类：

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
    implements Interface
{
    abstract public void abstractMethod();
}

public class InheritsFromInterfaceAndAbstractClass
    extends AbstractClass implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

但是，接口和抽象类之间存在两个区别。

第一个区别是接口无法实现方法。

interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

上面的接口生成编译器错误，因为它具有 的实现。如果你想实现该方法，但不能实例化该类，则必须像这样操作：implementedMethod()

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

这不是一个抽象类，因为它的成员都不是抽象的，但它是合法的Java。

接口和抽象类之间的另一个区别是，一个类可以从多个接口继承，但只能从一个抽象类继承。

abstract public class AbstractClassA { }
abstract public class AbstractClassB { }
public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

上面的代码生成编译器错误，不是因为类都是空的，而是因为 尝试从两个抽象类继承，这是非法的。以下是完全合法的。InheritsFromTwoAbstractClasses

interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{ }    

接口和抽象类之间的第一个区别是第二个区别的原因。请看下面的代码。

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}

上面的代码没有问题，因为没有什么可隐藏的。很容易看出调用将打印“method（）”。InterfaceAInterfaceBmethod

现在看下面的代码：

abstract public class AbstractClassA
{
    void method() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void method() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

这与我们的另一个示例完全相同，除了因为我们被允许在抽象类中实现方法，我们做到了，而且因为我们不必在继承类中实现已经实现的方法，所以我们没有。但你可能已经注意到，有一个问题。当我们打电话时会发生什么？它打印“你好”还是“再见”？你可能不知道，Java编译器也不知道。另一种语言，C++允许这种继承，他们以通常非常复杂的方式解决了这些问题。为了避免这种麻烦，Java决定将这种“多重继承”定为非法。new InheritsFromTwoAbstractClasses().method()

Java解决方案的缺点是无法做到以下几点：

abstract public class AbstractClassA
{
    void hi() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void bye() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

AbstractClassA并且是“mixins”或类，它们不打算实例化，而是向通过继承“混合”它们的类添加功能。显然，弄清楚如果你调用 或 会发生什么，显然没有问题，但你不能这样做，因为 Java 不允许这样做。AbstractClassBnew InheritsFromTwoAbstractClasses().hi()new InheritsFromTwoAbstractClasses().bye()

（我知道这是一篇很长的帖子，所以如果其中有任何错误，请让我知道，我会纠正它们。

接口是一种契约。一个简单的例子是租户和房东，他们是双方，合同是租赁协议。租赁协议包含租户必须遵守的各种条款。同样，接口是一个联系人，其中包含缔约方必须实现的各种方法（声明）（提供方法主体）。这里第一方是实现接口的类，第二方是客户端，使用和接口的方式是具有“接口的引用”和“实现类的对象”：下面是3个组件：（在示例的帮助下解释）

组件 1] 接口：合同

interface myInterface{

 public void myMethod();

 }

组件 2] 实现类：第 1 方

 class myClass implements myInterface {

 @Override

 public void myMethod() {

 System.out.println("in MyMethod");

 }

 }

组件 3] 客户端代码：第 2 方

 Client.java

 public class Client {

 public static void main(String[] args) {

 myInterface mi = new myClass();

 // Reference of Interface = Object of Implementing Class

 mi.myMethod(); // this will print in MyMethod

 }

 }