这个有点问题哈 接口不是类首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement. JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。 Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final). 接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。 An interface may never contain method definitions. 接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated. 接口不能被实例化。 A class that implements an interface must implement all of the methods described in the interface, or be an abstract class. 一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。 Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface. JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance. 使用接口的好处是他模拟多继承。 All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface. 所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。 第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。 两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口 例如： 假设你的Object是UFO，则 class MyObject implements UFO.... 可以这样定义： UFO anObject = new MyObject... 如果你的MyObject变成飞机 class MyObject implements Plane 那么 Plane anObject = new MyObject接口是混合类型的类项选择 如上，这样定义 class MyObject implements UFO, Plane.... 那么用instanceof来测试你的object是否是某个类型 在这个基础上，有部分接口被定义成空接口， 例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架 这个有点复杂，具体的你就看书吧！ 作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构， 并且以JAVA的集合框架为例说明了自己的构想
接口提供了面向对象所需要的一些思想，比如可扩展啦，就拿sun公司开发的JAVA语言来说，它本身就是一大堆的接口。 例如：JDBC,sun公司就是开发了一些接口，定义一个大家都能认可的标准，好让sql,orc等数据的开发公司都去遵循这个接口来实现它们之间的连接。 public interface Driver{ //假如这个接口是sun定义的JDBC接口那么sql等一些数据库只需要去实现这个接口就行了。 //而我们则只需要去调用就行了。 public Connection getConnection(); } 简单的说：比如你开发一个项目，后台代码是一个人写的，前台代码是两个人写的，那么这前台的这两个人只需要知道他们所需要调用的这个类的接口就行了，根本不需要去了解里面是怎么实现了。
引用自以上几楼： 首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement. JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。 Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final). 接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。 An interface may never contain method definitions. 接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated. 接口不能被实例化。 A class that implements an interface must implement all of the methods described in the interface, or be an abstract class. 一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。 Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface. JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance. 使用接口的好处是他模拟多继承。 All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface. 所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。 第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。 两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口 例如： 假设你的Object是UFO，则 class MyObject implements UFO.... 可以这样定义： UFO anObject = new MyObject... 如果你的MyObject变成飞机 class MyObject implements Plane 那么 Plane anObject = new MyObject接口是混合类型的类项选择 如上，这样定义 class MyObject implements UFO, Plane.... 那么用instanceof来测试你的object是否是某个类型 在这个基础上，有部分接口被定义成空接口， 例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架 这个有点复杂，具体的你就看书吧！ 作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构， 并且以JAVA的集合框架为例说明了自己的构想
引用自以上几楼： 首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement. JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。 Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final). 接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。 An interface may never contain method definitions. 接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated. 接口不能被实例化。 A class that implements an interface must implement all of the methods described in the interface, or be an abstract class. 一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。 Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface. JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance. 使用接口的好处是他模拟多继承。 All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface. 所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。 第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。 两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口 例如： 假设你的Object是UFO，则 class MyObject implements UFO.... 可以这样定义： UFO anObject = new MyObject... 如果你的MyObject变成飞机 class MyObject implements Plane 那么 Plane anObject = new MyObject接口是混合类型的类项选择 如上，这样定义 class MyObject implements UFO, Plane.... 那么用instanceof来测试你的object是否是某个类型 在这个基础上，有部分接口被定义成空接口， 例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架 这个有点复杂，具体的你就看书吧！ 作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构， 并且以JAVA的集合框架为例说明了自己的构想
@从本质上讲，接口也是是一种抽象类。这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
@多个无关的类可以实现同一个接口。一个类可以实现多个无关的接口。与继承关系类似，接口与实现类之间存在多态性。
java提供的接口都在相应的包中，通过引入包可以使用java提供的接口。也可以自己定义接口，一个java源文件就是由类和接口做成的。
Java中实现线程有两种方法，一种是继承Thread类，一种是实现Runnable接口
那么，对于某类A，其已经继承了某一父类B，有要求其实现线程相关功能，由于Java的单继承机制，A是无法继承Thread类的，此时就需要实现Runnable接口。
再比如我们要写很多动物的类，我们可以不要接口，分别写出各个动物的类包括它们具有的属性和方法，当这样做是不好的。我们大可以写一个动物的接口，其中包括一些方法，比如说eat(),sleep(),walking()....，这些方法都是动物所具有的共性，因为所有动物都吃，都睡觉，都会走路。
再写动物的类时，就可以实现那个动物接口。但具体的动物他们吃，睡觉的方式又不同，这样就可以分别覆写出不同的方法。但这样让人感到更舒服，思路更清晰一些。
接口的另一些好处就是上面的朋友们讲的了，也就是一个类可以实现多个接口，我也就不赘述了。
这个有点问题哈
接口不是类首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement.
JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。
Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final).
接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。
An interface may never contain method definitions.
接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated.
接口不能被实例化。
A class that implements an interface must implement all of the methods described in the interface, or be an abstract class.
一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。
Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.
JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance.
使用接口的好处是他模拟多继承。
All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface.
所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。
第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。
两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口
例如：
假设你的Object是UFO，则
class MyObject implements UFO....
可以这样定义：
UFO anObject = new MyObject...
如果你的MyObject变成飞机
class MyObject implements Plane
那么
Plane anObject = new MyObject接口是混合类型的类项选择
如上，这样定义
class MyObject implements UFO, Plane....
那么用instanceof来测试你的object是否是某个类型
在这个基础上，有部分接口被定义成空接口，
例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架
这个有点复杂，具体的你就看书吧！
作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构，
并且以JAVA的集合框架为例说明了自己的构想
例如：JDBC,sun公司就是开发了一些接口，定义一个大家都能认可的标准，好让sql,orc等数据的开发公司都去遵循这个接口来实现它们之间的连接。 public interface Driver{
//假如这个接口是sun定义的JDBC接口那么sql等一些数据库只需要去实现这个接口就行了。
//而我们则只需要去调用就行了。
public Connection getConnection();
}
简单的说：比如你开发一个项目，后台代码是一个人写的，前台代码是两个人写的，那么这前台的这两个人只需要知道他们所需要调用的这个类的接口就行了，根本不需要去了解里面是怎么实现了。
比如说金丝猴是一种动物，它从动物这个类继承了 但金丝猴同时也是受保护的物种，这个时候就不能继续继承受保护的物种这个类，但又想展现它这个特性，此时就可以定义一个受保护的物种这个接口来实现···
RMI，CORBA等服务总结楼上的每个朋友已经很好的解释了接口的概念了，但是我相信你还是没法理解，因为你没有切身体会过，所以楼主可以先大概了解一下，然后到实践中真正体会理解
首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement.
JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。
Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final).
接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。
An interface may never contain method definitions.
接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated.
接口不能被实例化。
A class that implements an interface must implement all of the methods described in the interface, or be an abstract class.
一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。
Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.
JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance.
使用接口的好处是他模拟多继承。
All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface.
所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。
第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。
两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口
例如：
假设你的Object是UFO，则
class MyObject implements UFO....
可以这样定义：
UFO anObject = new MyObject...
如果你的MyObject变成飞机
class MyObject implements Plane
那么
Plane anObject = new MyObject接口是混合类型的类项选择
如上，这样定义
class MyObject implements UFO, Plane....
那么用instanceof来测试你的object是否是某个类型
在这个基础上，有部分接口被定义成空接口，
例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架
这个有点复杂，具体的你就看书吧！
作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构，
并且以JAVA的集合框架为例说明了自己的构想
java菜鸟学堂QQ群144648357
PS：楼猪头像不错，是BY2吗？
首先看看wiki上对java的interface的解释（只是摘要）：An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement.
JAVA中的接口是一个抽象类型(abstract是抽象，总结的意思，论文中的ABSTRACT，是摘要的意思，那么)，这种类型用来指定一个类（CLASS）必须实现（implement）（这种抽象定义）。
Interfaces are declared using the interface keyword, and may only contain method signatures and constant declarations (variable declarations that are declared to be both static and final).
接口用interface关键字声明，并且只能包含方法签名和常量（即：用static final修饰的量）。
An interface may never contain method definitions.
接口不能包含方法实体。（包括大括号在内的所有都不能有）Interfaces cannot be instantiated.
接口不能被实例化。
A class that implements an interface must implement all of the methods described in the interface, or be an abstract class.
一个类，它要么实现接口中描述的所有方法（然后这就是常见类），要么这个类实现接口中的一部分方法，然后这个类被标记成抽象类。
Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.
JAVA中对象的引用可以标记为一个接口，这种情况下，这些对象要么是null，要么实例化成为实现了这个接口的类的实例。One benefit of using interfaces is that they simulate multiple inheritance.
使用接口的好处是他模拟多继承。
All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of interfaces; however an interface may not implement an interface.
所有JAVA的类（除去java.lang.Object，这是JAVA体系所有类的基类）必须有一个基准类（基类或父类），（JAVA中）多继承是禁止的。故而：一个JAVA类可以“实现”多个接口，一个接口可以“继承”多个接口，但是一个接口不能实现一个接口以上是wiki的解释，值得仔细推敲。来看大师的解释：《JAVA核心技术》上原话：接口不是类（204页，6.1节第一自然段），它是对类的一组需求的描述。
第210页： JAVA的设计者选择了不支持多继承，因为多继承让语言本身变得非常复杂，效率也会降低。《Effective Java》：第82页：第18条：接口优于抽象类。
两种机制的明显区别在于：抽象类允许包含某些方法的实现，但是接口不允许。另一个区别在于，实现抽象类的类处在继承层次中（这引起复杂），而实现接口的类不必在乎他所处的层次结构，并且可以实现多个接口。现有的类可以很容易被更新，以实现新的接口
例如：
假设你的Object是UFO，则
class MyObject implements UFO....
可以这样定义：
UFO anObject = new MyObject...
如果你的MyObject变成飞机
class MyObject implements Plane
那么
Plane anObject = new MyObject接口是混合类型的类项选择
如上，这样定义
class MyObject implements UFO, Plane....
那么用instanceof来测试你的object是否是某个类型
在这个基础上，有部分接口被定义成空接口，
例如java.lang.Cloneable，很多是有仅仅是用instanceof来检测一个对象是否可以被克隆，因此它不包含方法签名。接口允许我们构造非层次结构的类型框架
这个有点复杂，具体的你就看书吧！
作者把接口和抽象类结合起来实现了一个抽象的骨架实现，打破了集成层次结构，
并且以JAVA的集合框架为例说明了自己的构想
interface Person{ //接口 1
void setAge(int age);
void setName(String name);
int getAge();
String getName();
}
interface SuperMan{ //接口2
void setSex(char sex);
char getSex();
}
class Student implements Person,SuperMan //此处还可以继承一个类 （extends TestClass）放在implements前边
{
private int age;
private String name;
private char sex;
//实现接口中的方法
public void setAge(int age){
this.age=age;
}
public void setName(String name) {
this.name=name;
}
public int getAge() {
return age;
} public String getName() {
return name;
}
public void setSex(char sex) {
this.sex=sex;
}
public char getSex() {
return sex;
}
}
觉得还行就给分吧。。
直接写一个类。那样也许很方便，但是使得那个抽象东西太过局限，代码重用类就降低了。
还有就是楼上说的（在一个团队里，每个人负责不同的模块，如果不使用接口，而用具体的类去实现不同的功能，那么一旦有修改，势必会影响到他人所编写的代码，而用接口，程序员修改的是自己编写的类，与他人的无关，这一切都因为接口提供了一套公共的方法，而每个程序员都有自己的一套实现方法，互不干扰）