Java中的接口是什么？
就像这个问题的对应点：Java中的接口是什么？
接口是抽象类的一种特殊forms，它不实现任何方法。 在Java中，您可以像这样创build一个接口：
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! }
你不能这样做的原因是y是interfaceA的types， interfaceA中没有interfaceMethodB() 。 同样， z的types是interfaceMethodA() ， interfaceB没有interfaceMethodA() 。
我之前提到接口只是一个抽象类的特殊forms。 为了说明这一点，请看下面的代码。
interface Interface { void abstractMethod(); } abstract public class AbstractClass { abstract public void abstractMethod(); }
你可以从这些类inheritance几乎完全一样的方式：
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。
接口和抽象类之间的另一个区别是一个类可以从多个接口inheritance，但只能从一个抽象类inheritance。
abstract public class AbstractClassA { } abstract public class AbstractClassB { } public class InheritsFromTwoAbstractClasses extends AbstractClassA, AbstractClassB { }
上面的代码生成一个编译器错误，不是因为这些类都是空的，而是因为InheritsFromTwoAbstractClasses试图从两个抽象类inheritance，这是非法的。 以下是完全合法的。
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()"); } }
上面的代码没有问题，因为InterfaceA和InterfaceB没有任何隐藏的东西。 很容易知道调用method会打印“method（）”。
现在看下面的代码：
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 { }
这与我们的另一个例子完全一样，只是因为我们被允许在抽象类中实现方法，所以我们做了，因为我们不必在inheritance类中实现已经实现的方法，所以我们没有。 但是你可能已经注意到了，有一个问题。 当我们调用new InheritsFromTwoAbstractClasses().method()时会发生什么？ 它打印“你好”还是“再见”？ 你可能不知道，Java编译器也不知道。 另一种语言，C ++允许这种inheritance，他们通过非常复杂的方式解决了这些问题。 为了避免这种麻烦，Java决定把这个“多重inheritance”非法。
Java解决scheme的不利之处在于以下方面无法完成：
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和AbstractClassB是“mixins”或类，它们并不打算被实例化，而是通过inheritance将其“混合到”的类添加function。 如果调用new InheritsFromTwoAbstractClasses().hi()或new InheritsFromTwoAbstractClasses().bye()函数，会发生什么情况显然没有问题，但是由于Java不允许，所以不能这样做。
（我知道这是一个很长的post，所以如果有任何错误，请让我知道，我会纠正它们。）
java中的一个接口是一个类的蓝图。 它只有静态常量和抽象方法。java中的接口是一个完全抽象的机制。 在java接口not方法体中只能有抽象方法。 它用于在Java中实现完全抽象和多重inheritance。 一个接口是抽象方法的集合。 一个类实现了一个接口，从而inheritance了接口的抽象方法。 一个接口不是一个类。 编写一个接口类似于编写一个类，但它们是两个不同的概念。 一个类描述了一个对象的属性和行为。 一个接口包含一个类实现的行为（抽象方法）。 除非实现接口的类是抽象的，否则接口的所有方法都需要在类中定义。由于Java中不允许多inheritance，因此接口只能实现多重inheritance。 这里是一个理解界面的例子
interface Printable{ void print(); } interface Showable{ void print(); } class testinterface1 implements Printable,Showable{ public void print(){System.out.println("Hello");} public static void main(String args[]){ testinterface1 obj = new testinterface1(); obj.print(); } }
界面是一个阶级的蓝图。
有一个叫做数据抽象的概念，有两个类，一个是抽象类 ，另一个是接口 。
抽象类只实现了部分抽象，而接口则完全抽象化。
在接口中只有抽象方法和最终variables..你可以扩展任意数量的接口，你可以实现任意数量的类。
如果任何类正在实现接口，那么类也必须实现抽象方法
接口不能被实例化。
interface A() { void print() }
这个问题已经有6年了，很多东西都改变了界面的定义。
从oracle 文档页面（在Java 8发布后）：
在Java编程语言中，接口是一个引用types，类似于一个类，它只能包含常量，方法签名，缺省方法，静态方法和嵌套types 。 方法体仅存在于默认方法和静态方法中。 接口不能被实例化 – 它们只能由类实现或由其他接口扩展。
看看相关的SE问题以获得更好的解释：
有更多的接口比正确的方法
界面和抽象类有什么区别？
像一个类一样，一个接口可以有方法和variables，但是在接口中声明的方法默认是抽象的（只有方法签名，没有主体）。
- 接口指定一个类必须做什么，而不是如何。 这是class级的蓝图。
-
一个接口是关于像一个播放器的function可能是一个接口和任何类实现播放器必须能够（或必须执行）移动（）。 所以它指定了这个类必须实现的一组方法。
-
如果一个类实现了一个接口，并且不为接口中指定的所有函数提供方法体，那么类必须声明为抽象的。
接口被用来实现抽象 。 所以当我们有抽象类的时候，为什么要使用接口呢？
原因是，抽象类可能包含非最终variables，而接口中的variables是最终的，公共的和静态的 。
在JDK 8中添加了新的function
-
在JDK 8之前，接口无法定义实现。 我们现在可以添加接口方法的默认实现。 这个默认实现有特殊的用处，并不影响接口背后的意图。
假设我们需要在现有的接口中添加一个新的函数。 很明显，旧的代码将不会工作，因为类没有实现这些新的function。 所以在默认实现的帮助下，我们将为新添加的函数提供一个默认的主体。 那么旧的代码将仍然有效。
- 在JDK 8中，我们现在可以在不需要对象的情况下独立调用接口中的静态方法。 注意：这些方法不被inheritance。
这是什么
一个接口是一个引用types，就像一个类一样。 这些是Java中的两个主要参考types。
它包含什么
一个接口可以包含普通类可以包含的子集。 这包括static方法和variables，以及非static方法声明。 不允许有非staticvariables。
一个方法的声明有几个不同于一般的方法; 这里是一个例子：
[public] [abstract] ReturnType methodName();
这些声明可以标记为public和abstract ，用[optional braces] 。 没有必要这样做，因为这是默认设置。 private ， protected ， package-private （也就是没有）， final修饰符是不允许的，并且标记为编译器错误。 他们没有实现，所以有一个分号，而不是花括号。
从Java 8开始，它们可以 通过一个实现来保存非static方法，这些方法必须使用default修饰符进行标记。 但是，与其他修饰符相同的限制也适用（添加了strictfp现在是有效的， abstract不再）。
什么是有用的
它的一个用途就是将其用作服务的一面。 当双方合作形成服务请求者和服务提供者关系时，服务提供者以接口的forms提供服务的面貌（至于服务的外观）。
面向对象的概念之一是“抽象”，意思是隐藏系统的复杂工作，只显示理解系统的必要条件。 这有助于可视化复杂系统的工作。 这可以通过在每个模块中可视化（并且实现）的接口来实现，以通过另一个模块的接口来工作
一个接口是一个只包含常量和抽象方法的类结构（Java编程入门，nd）。 而且，它可以扩展多个接口，例如一个超类。 Java只允许对类扩展进行单一inheritance，但是允许对接口进行多重扩展（Java编程简介nd）例如，
public class NewClass extends BaseClass implements Interface1, ..., InterfaceN { ... }
其次，可以使用接口来指定类中对象的行为。 但是，它们不能包含抽象方法。 另外，接口可以使用extends关键字inheritance其他接口。
public interface NewInterface extends Interface1, ... , InterfaceN { }
参考
Java编程简介。 接口和抽象类（nd）。 2017年3月10日从https://viewer.gcu.edu/7NNUKW检索;
一般来说，当我们有更多的实现时，我们更喜欢接口。 接口在哪里作为协议。
编码到接口，而不是实现编码到接口使得松散耦合。
一个接口是Java中的一个引用types 。 它类似于课堂。 它是一个抽象方法的集合。 一个类实现了一个接口，从而inheritance了接口的抽象方法。 除了抽象方法外，接口还可以包含常量，缺省方法，静态方法和嵌套types。 了解更多细节
