一：概念
接口是功能的集合。同样可以看做一种数据类型，是比抽象类更为抽象的“类”。
接口描述应该具备的方法，并没有具体的实现。具体实现由接口的实现类（相当于接口的子类来完成）。
好处：
使功能和实现分离，优化了程序设计。
二：语法
使用关键字interface关键字来定义。
定义的接口文件仍然是.java文件。虽然声明的时候使用interface关键字，编译之后仍然是.class
文件。接口我们可以把他看做是一种只包含了功能声明的特殊类。
定义格式:
public interface 接口名字{
抽象方法1（public abstract 返回值类型 方法名字(参数列表);）
抽象方法1（public abstract 返回值类型 方法名字(参数列表);）
抽象方法1（public abstract 返回值类型 方法名字(参数列表);）
.......
}
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定义： 6 * 修饰符 interface 接口名字 7 * 方法的定义: 8 * public abstract 返回值类型 方法名字 (参数列表) 9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰. 10 * 成员的变量的定义:必须是常量且修饰符为public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 }
注意：
在接口内的方法，必须是public修饰符，以及为抽象方法（abstract）。
三：接口的实现
我们把实现接口的类叫做接口的实现。
1 package com.company; 2 3 /** 4 * 接口的实现语法： 5 * 使用关键字implements. 6 * 修饰符 类名字 implements 接口名字{ 7 * public 返回值类型 抽象方法的名字{ 8 * 方法体. 9 * } 10 * } 11 * 类的名字 关键字 接口名字 12 * public class Myimple implements Myinterface 13 */ 14 15 16 17 public class Myimple implements Myinterface { 18 public int myinter(){ 19 return 2; 20 }; 21 }
注意:
在接口中默认方法都是抽象的（abstract）,不管是否使用public abstract，都一样
抽象的方法重写，修饰符是public 注意访问权限 只能是public.而且是普通方法。（没有abstract，abstract是抽象方法的定义。）
类是接口的实现，类似于类是接口的子类，接口继承。但是实际上类是接口的实现。
如果接口中有多个抽象方法，实现类需要把接口的抽象方法都一一实现。
接口类的中的抽象方法和接口的成员变量访问权限都是public，写和不写都是这个权限，实现类中的方法的权限也必须是public。否则报错！！！
如果一个实现类中并没有实现接口的所有的抽象方法，如果依然是普通类，会报错，普通类需要实现所有的接口的方法，而实现类变为抽象类就不会报错。也就是说
实现部分接口的抽象方法，实现类是抽象类。
接口:
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定义： 6 * 修饰符 interface 接口名字 7 * 方法的定义: 8 * public abstract 返回值类型 方法名字 (参数列表) 9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰. 10 * 成员的变量的定义:必须是常量且修饰符为public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 public abstract void myinter1(); 15 }
实现类:
1 public abstract class Myimple implements Myinterface { 2 public int myinter(){ 3 return 2; 4 }; 5 }
调用：
通过初始化实现类对象来调用相应的方法：
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 6 System.out.println(shixian.myinter()); 7 } 8 }
接口的多实现：
类的继承只能单继承，而接口不一样，可以同实现类实现多个接口，这个也是比抽象类更加灵活。
实现类C可以同时实现接口A和B。
接口A：
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定义： 6 * 修饰符 interface 接口名字 7 * 方法的定义: 8 * public abstract 返回值类型 方法名字 (参数列表) 9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰. 10 * 成员的变量的定义:必须是常量且修饰符为public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 15 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
实现C：
1 public class Myimple implements Myinterface ,Myinterfac_b{ 2 public int myinter(){ 3 return 2; 4 }; 5 }
因为接口A 和B的抽象方法是一样，所以实现类C可以重写一个类即可。
但是前提：
1：重写方法 返回值一样。如果不一样的话，需要分别实现，不能一起实现。
2：如果方法的参数列表不一样。我们可以重载。
接口A：
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定义： 6 * 修饰符 interface 接口名字 7 * 方法的定义: 8 * public abstract 返回值类型 方法名字 (参数列表) 9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰. 10 * 成员的变量的定义:必须是常量且修饰符为public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(String a); 14 15 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
实现C：
package com.company; public class Mytest { public static void main(String ... arg){ Myimple shixian=new Myimple(); System.out.println(shixian.myinter()); System.out.println(shixian.myinter("ok")); } }
注意：
决定方法的差异是方法的签名，方法的签名包含方法的名字和参数！
接口的多继承：
接口可以进行多继承，但是最后子接口，在被实现的时候，需要实现所有父接口的抽象方法。也就是说在java中有多继承的概念。
接口A：
1 public interface Myinterface { 2 /** 3 *接口定义： 4 * 修饰符 interface 接口名字 5 * 方法的定义: 6 * public abstract 返回值类型 方法名字 (参数列表) 7 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰. 8 * 成员的变量的定义:必须是常量且修饰符为public . 9 */ 10 public static final int c=22; 11 public abstract int myinter(String a); 12 13 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
接口C：
1 package com.company; 2 3 public interface Myinter_c extends Myinterfac_b,Myinterface { 4 public abstract double myinter_c(); 5 }
实现：
1 public class Myimple implements Myinter_c{ 2 public int myinter(){ 3 return 2; 4 }; 5 6 @Override 7 public int myinter(String a) { 8 return 3; 9 } 10 public double myinter_c(){ 11 return 4; 12 } 13 }
调用：
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 6 System.out.println(shixian.myinter()); 7 System.out.println(shixian.myinter("ok")); 8 System.out.println(shixian.myinter_c()); 9 } 10 }
注意：
最后实现：如果实现的C的接口时候，实现类中需要把各个抽象方法都要一一实现。这叫做接口的多继承。
抽象类和接口的区别：
抽象类：是事务共有的功能，但是功能由于具体的对象的不同导致实现内容不一样。
接口：是事务额外的功能，如果事务想具备这个功能，需要定义相应的接口，由实现类来实现。
人的共有的功能：吃和睡觉。但是每个吃什么和怎么睡觉是不一样的。但都属于人的共有的功能。人是否编程功能，不一定，属于人的额外功能。所以吃和睡是抽象，编程是接口。
抽象类：
1 package com.company; 2 3 public abstract class Person_t { 4 public abstract void eat(); 5 public abstract void sleep(); 6 public String work(){ 7 return "make money"; 8 } 9 }
接口：
1 package com.company; 2 3 public interface Per_in { 4 public abstract void biancheng(); 5 }
实现类和实现抽象类的抽象方法：
1 package com.company; 2 3 4 5 public class Beav extends Person_t implements Per_in { 6 public void eat(){ 7 System.out.println("apple"); 8 } 9 public void sleep(){ 10 System.out.println("sleep at 500"); 11 } 12 public void biancheng(){ 13 System.out.println("java"); 14 } 15 }
调用类：
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Beav new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
注意：
抽象类中不一定只有抽象方法，也可以有普通方法。抽象类通过子类来调用和实现抽象方法和普通方法。
接口只有抽象方法和常量。没有普通方法。
接口需要实现（implements），抽象方法需要继承（extends），抽象是多态实现，而接口是功能和实现分离。
接口也可以这么写 接口 变量 =new 子类的构造器();这是接口的多态。
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Per_in new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
多态是指对象在不同的情形下，对应的类型不同。接口通过实现类来实现多态，类通过继承，子类实现多态。