一、接口的概念
Java接口是一系列方法的声明，是一些方法特征的集合，（如：“人”的“食、宿”问题。）一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
1 //interface 定义的关键字 ，接口都需要实现类 2 public interface UserService { 3 //接口中所有的定义都是抽象的 4 5 //常量 public static final 6 public static final int age=99; 7 /*public abstract*/ void add(String name); 8 void delete(String name); 9 void updete(String name); 10 void query(String name); 11 12 } 13 14 public interface TimeService { 15 void timer(); 16 } 17 18 19 20 //抽象类：extends 21 //一个类可以实现接口，imlements接口 22 //实现了接口的类，就需要重写接口中的方法 23 24 //多继承~利用接口实现多继承~ 25 public class UserServiceImp1 implements UserService,TimeService{ 26 @Override 27 public void add(String name) { 28 29 } 30 31 @Override 32 public void delete(String name) { 33 34 } 35 36 @Override 37 public void updete(String name) { 38 39 } 40 41 @Override 42 public void query(String name) { 43 44 } 45 46 @Override 47 public void timer() { 48 49 } 50 }
二、接口的使用
1、由于接口里面存在抽象方法，所以接口对象不能直接使用关键字new进行实例化。接口的使用原则如下： （1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口； （2）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法； （3）接口的对象可以利用子类对象的向上转型进行实例化。
范例：
1 package com.wz.interfacedemo; 2 3 interface A{//定义一个接口A 4 5 public static final String MSG = "hello";//全局常量 6 7 public abstract void print();//抽象方法 8 } 9 10 interface B{//定义一个接口B 11 12 public abstract void get(); 13 } 14 15 class X implements A,B{//X类实现了A和B两个接口 16 17 @Override 18 public void print() { 19 System.out.println("接口A的抽象方法print()"); 20 } 21 22 @Override 23 public void get() { 24 System.out.println("接口B的抽象方法get()"); 25 } 26 27 } 28 29 public class TestDemo { 30 31 public static void main(String[] args){ 32 33 X x = new X();//实例化子类对象 34 A a = x;//向上转型 35 B b = x;//向上转型 36 37 a.print(); 38 b.get(); 39 } 40 41 }
运行结果：
接口A的抽象方法print()
接口B的抽象方法get()
以上的代码实例化了X类的对象，由于X类是A和B的子类，那么X类的对象可以变为A接口或者B接口对象。我们把测试主类代码改一下：
public class TestDemo { public static void main(String[] args){ A a = new X(); B b = (B) a; b.get(); } }
运行结果：
接口B的抽象方法get()
好，没任何问题，我们再来做个验证：
public class TestDemo { public static void main(String[] args){ A a = new X(); B b = (B) a; b.get(); System.out.println(a instanceof A); System.out.println(a instanceof B); }
运行结果：
接口B的抽象方法get()
true
true
我们发现，从定义结构来讲，A和B两个接口没有任何直接联系，但这两个接口却拥有同一个子类。我们不要被类型和名称所迷惑，因为实例化的是X子类，而这个类对象属于B类的对象，所以以上代码可行，只不过从代码的编写规范来讲，并不是很好。
2、对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口的话，使用一下语法格式：
class 子类 [extends 父类] [implemetns 接口1,接口2,...] {}1
范例：
1 interface A{//定义一个接口A 2 3 public static final String MSG = "hello";//全局常量 4 5 public abstract void print();//抽象方法 6 } 7 8 interface B{//定义一个接口B 9 10 public abstract void get(); 11 } 12 13 abstract class C{//定义一个抽象类C 14 public abstract void change(); 15 } 16 17 class X extends C implements A,B{//X类继承C类，并实现了A和B两个接口 18 19 @Override 20 public void print() { 21 System.out.println("接口A的抽象方法print()"); 22 } 23 24 @Override 25 public void get() { 26 System.out.println("接口B的抽象方法get()"); 27 } 28 29 @Override 30 public void change() { 31 System.out.println("抽象类C的抽象方法change()"); 32 33 } 34 35 }
对于接口，里面的组成只有抽象方法和全局常量，所以很多时候为了书写简单，可以不用写public abstract 或者public static final。并且，接口中的访问权限只有一种：public，即：定义接口方法和全局常量的时候就算没有写上public，那么最终的访问权限也是public，注意不是default。以下两种写法是完全等价的：
interface A{
public static final String MSG = "hello";
public abstract void print();
}
等价于
interface A{
String MSG = "hello";
void print();
}
但是，这样会不会带来什么问题呢？如果子类子类中的覆写方法也不是public，我们来看：
package com.wz.interfacedemo; interface A{ String MSG = "hello"; void print(); } class X implements A{ void print() { System.out.println("接口A的抽象方法print()"); } } public class TestDemo { public static void main(String[] args){ A a = new X(); a.print(); } }
运行结果：
Exception in thread "main" java.lang.IllegalAccessError: com.wz.interfacedemo.X.print()V
at com.wz.interfacedemo.TestDemo.main(TestDemo.java:22)12
这是因为接口中默认是public修饰，若子类中没用public修饰，则访问权限变严格了，给子类分配的是更低的访问权限。所以，在定义接口的时候强烈建议在抽象方法前加上public ，子类也加上：
interface A{
String MSG = "hello";
public void print();
}
class X implements A{
public void print() {
System.out.println("接口A的抽象方法print()");
}
}
3、在Java中，一个抽象类只能继承一个抽象类，但一个接口却可以使用extends关键字同时继承多个接口（但接口不能继承抽象类）。
范例：
interface A{ public void funA(); } interface B{ public void funB(); } //C接口同时继承了A和B两个接口 interface C extends A,B{//使用的是extends public void funC(); } class X implements C{ @Override public void funA() { } @Override public void funB() { } @Override public void funC() { } }
由此可见，从继承关系来说接口的限制比抽象类少： （1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口； （2）一个子类只能继承一个抽象类，却可以实现多个接口（在Java中，接口的主要功能是解决单继承局限问题）
4、从接口的概念上来讲，接口只能由抽象方法和全局常量组成，但是内部结构是不受概念限制的，正如抽象类中可以定义抽象内部类一样，在接口中也可以定义普通内部类、抽象内部类和内部接口（但从实际的开发来讲，用户自己去定义内部抽象类或内部接口的时候是比较少见的），范例如下，在接口中定义一个抽象内部类：
interface A{ public void funA(); abstract class B{//定义一个抽象内部类 public abstract void funB(); } }
在接口中如果使用了static去定义一个内接口，它表示一个外部接口：
interface A{ public void funA(); static interface B{//使用了static，是一个外部接口 public void funB(); } } class X implements A.B{ @Override public void funB() { } }
三、接口的用法
1、精简程序结构，免除重复定义
比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。
举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。
下图是分别定义鸟类和昆虫类，其都有飞行的方法。
下图定义了接口，其类图如下：
实现代码如下：
1 interface Flyanimal{ 2 void fly(); 3 } 4 class Insect { 5 int legnum=6; 6 } 7 class Bird { 8 int legnum=2; 9 void egg(){}; 10 } 11 class Ant extends Insect implements Flyanimal { 12 public void fly(){ 13 System.out.println("Ant can fly"); 14 } 15 } 16 class Pigeon extends Bird implements Flyanimal { 17 public void fly(){ 18 System.out.println("pigeon can fly"); 19 } 20 public void egg(){ 21 System.out.println("pigeon can lay eggs "); 22 } 23 } 24 public classInterfaceDemo{ 25 public static void main(String args[]){ 26 Ant a=new Ant(); 27 a.fly(); 28 System.out.println("Ant's legs are"+ a.legnum); 29 Pigeon p= new Pigeon(); 30 p.fly(); 31 p.egg(); 32 } 33 }
程序运行结果：
Ant can fly
Ant'slegs are 6
pigeon can fly
pigeon can lay eggs
二、拓展程序功能，应对需求变化。
假设一个学校接待方面的程序，招待不同身份的人的食宿问题，其对应规则如下：
| 身份 | 食 | 宿 |
|---|---|---|
| 学生 | 食堂 | 宿舍 |
| 教师 | 教师食堂 | 学校公寓 |
| 学生家长 | 招待所 | 招待所 |
理论上，当然可以对每个不同身份的人各定义一个对应的类，并实现各自的方法，但是观察这写类，可以归纳出其有一个共同的模板，即“人”的“食、宿”问题。这时候，就可以发挥接口的功能了。实现代码如下：
1 interface Person{ 2 void eat(); 3 void sleep(); 4 } 5 6 class Student implements Person{ 7 public void eat(){ 8 System.out.println("学生去食堂吃饭！"); 9 } 10 public void sleep(){ 11 System.out.println("学生回寝室睡觉！"); 12 } 13 } 14 15 class Teacher implements Person{ 16 public void eat(){ 17 System.out.println("教师去教工餐厅吃饭！"); 18 } 19 public void sleep(){ 20 System.out.println("教师回学校公寓睡觉！"); 21 } 22 } 23 class Parents implements Person{ 24 publicvoid eat(){ 25 System.out.println("家长去招待所饭馆吃饭！"); 26 } 27 public void sleep(){ 28 System.out.println("家长回招待所睡觉！"); 29 } 30 } 31 32 public class PersonInterface{ 33 public static void main(String[] args) 34 { 35 Person p=new Student(); 36 p.eat(); 37 p.sleep(); 38 p=new Teacher(); 39 p.eat(); 40 p.sleep(); 41 p=new Parents(); 42 p.eat(); 43 p.sleep(); 44 } 45 }
程序执行结果：
学生去食堂吃饭！
学生回寝室睡觉！
教师去教工餐厅吃饭！
教师回学校公寓睡觉！
家长去招待所饭馆吃饭！
家长回招待所睡觉！
现在需要添加一些功能，即现在需要添加“外宾、上级领导”两类角色，并且以后工具需要还要添加相应的身份角色的人进来，此时，只需要根据需要添加“外宾”类、“领导”类，而主类仍然可以拿来就用，无需进行更多的修改。此时就可以显示出接口的作用了。
在上面的程序中添加如下两个类即可。
1 class Foreign implements Person{ 2 publicvoid eat(){ 3 System.out.println("外宾去酒店吃饭！"); 4 } 5 public void sleep(){ 6 System.out.println("外宾回酒店睡觉！"); 7 } 8 } 9 10 class Leader implements Person{ 11 publicvoid eat(){ 12 System.out.println("领导去宾馆吃饭！"); 13 } 14 public void sleep(){ 15 System.out.println("外宾回宾馆睡觉！"); 16 } 17 }
而主函数中用法仍然一样。
下面给出完整的代码：
1 interfacePerson{ 2 void eat(); 3 void sleep(); 4 } 5 6 class Studentimplements Person{ 7 public void eat(){ 8 System.out.println("学生去食堂吃饭！"); 9 } 10 public void sleep(){ 11 System.out.println("学生回寝室睡觉！"); 12 } 13 } 14 15 class Teacherimplements Person{ 16 public void eat(){ 17 System.out.println("教师去教工餐厅吃饭！"); 18 } 19 public void sleep(){ 20 System.out.println("教师回学校公寓睡觉！"); 21 } 22 } 23 class Parents implements Person{ 24 publicvoid eat(){ 25 System.out.println("家长去招待所饭馆吃饭！"); 26 } 27 public void sleep(){ 28 System.out.println("家长回招待所睡觉！"); 29 } 30 } 31 class Foreign implements Person{ 32 publicvoid eat(){ 33 System.out.println("外宾去酒店吃饭！"); 34 } 35 public void sleep(){ 36 System.out.println("外宾回酒店睡觉！"); 37 } 38 } 39 40 class Leader implements Person{ 41 publicvoid eat(){ 42 System.out.println("领导去宾馆吃饭！"); 43 } 44 public void sleep(){ 45 System.out.println("领导回宾馆睡觉！"); 46 } 47 } 48 49 public class PersonInterface{ 50 public static void main(String[] args) 51 { 52 Person p=new Student(); 53 p.eat(); 54 p.sleep(); 55 p=new Teacher(); 56 p.eat(); 57 p.sleep(); 58 p=new Parents(); 59 p.eat(); 60 p.sleep(); 61 p=new Foreign(); 62 p.eat(); 63 p.sleep(); 64 p=new Leader(); 65 p.eat(); 66 p.sleep(); 67 } 68 }
程序执行结果：
学生去食堂吃饭！
学生回寝室睡觉！
教师去教工餐厅吃饭！
教师回学校公寓睡觉！
家长去招待所饭馆吃饭！
家长回招待所睡觉！
外宾去酒店吃饭！
外宾回酒店睡觉！
领导去宾馆吃饭！
领导回宾馆睡觉！
举例二：
用来计算每一种交通工具运行1000公里所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：
Car 和Plane，其中Car 的速度运算公式为：A*B/C
Plane 的速度运算公式为：A+B+C。
如果增加第3种交通工具的时候，比如火车（Train）不必修改以前的任何程序，只需要编写新的交通工具的程序。
import java.lang.*; interface Common { double runTimer(doublea, double b, double c); String getName(); //获取交通工具的名称 } class Plane implementsCommon { public doublerunTimer(double a, double b, double c) { return (a+ b + c); } public String getName(){ return"Plane"; } } class Car implements Common { public doublerunTimer(double a, double b, double c) { return ( a*b/c ); } public String getName(){ return"Car"; } } public class ComputeTime { public static void main(Stringargs[]) { double A=3; double B=5; double C=6; double v,t; Commond=new Car(); v=d.runTimer(A,B,C); t=1000/v; System.out.println(d.getName()+"的平均速度: "+v+" km/h"); System.out.println(d.getName()+"的运行时间："+t+" 小时"); d=newPlane(); v=d.runTimer(10,30,40); t=1000/v; System.out.println(d.getName()+"的平均速度: "+v+" km/h"); System.out.println(d.getName()+"的运行时间："+t+" 小时"); } }
程序运行结果；
Car的平均速度: 2.5 km/h
Car的运行时间：400.0 小时
Plane的平均速度: 80.0 km/h