interface
引用数据类型：类、数组、接口
1 接口概述
接口是对Java单继承的补充。Java只支持单继承（亲爹唯一），如果在开发过程中想额外增强类的功能，可以借助接口实现（可以拜师，拜多个师傅也可以）。
接口是Java中一种重要的抽象机制，它提供了一种定义行为规范和实现多态性的方式。通过合理使用接口，可以提高代码的可扩展性、可维护性和灵活性。
接口是除了类和数组之外，另外一种引用数据类型，需要使用 interface 关键字来定义，接口最终也会被编译成.class文件，但一定要明确接口并不是类，而是另外一种引用数据类型。
接口基础定义格式：
[修饰符] interface 接口名 { //数据成员，可以定义多个 [public static final] 数据类型 数据成员 = 值; //抽象方法：可以定义多个 [public abstract] 返回值类型 方法名(形参列表);}案例如下：
package com.briup.chap07.test;//使用interface关键字来定义接口interface IAction {//数据成员,下面2行效果一样//public static final int NUM = 10;int NUM = 10;//成员方法,下面2行效果一样//public abstract void start();void start();public abstract void end();}public class Test021_Basic {public static void main(String[] args) {//接口不可以实例化对象 //IAction ac = new IAction(); error System.out.println(IAction.NUM); //接口中数据成员默认 public static final，故而下行编译报错 //IAction.NUM = 20;}}注意1， 定义类使用关键字class，定义接口使用关键字interface
注意2，接口中的数据成员，默认public static final修饰，是常量，名称全大写（符合命名规范）
注意3，接口中的方法，默认public abstract修饰，是抽象方法
补充内容（后面章节具体讨论）：
JDK8中，还允许在接口中编写静态方法和默认方法
JDK9中，还允许在接口中编写私有方法
2 接口实现
Java中类和类之间的关系是继承，且只能是单继承
类和接口是实现关系，通过implements关键字表示，可以是单实现，也可以是多实现
子类还可以在继承一个父类的同时实现多个接口
接口的实现类书写格式：
//一个类可以同时实现多个接口[修饰符] class 类名 implements 接口名1,接口名2,... {重写所有抽象方法}注意事项：
接口属于引用数据类型的一种，它不是类，它没有构造方法接口的实现类（子类），可以是正常类（重写所有抽象方法），也可以是抽象类（包含抽象方法）接口不能创建对象，一般用接口引用指向实现类对象相同接口的多个实现类，体现的是like a的关系 基础案例：
实现类实现单个接口案例。
定义IAction的实现类，重写所有抽象方法，最后进行功能测试。
package com.briup.chap07.test;interface IAction {int NUM = 10;void start();public abstract void end();}//定义接口的实现类class ActionImpl implements IAction {@Overridepublic void start() {System.out.println("start开始执行 ");}@Overridepublic void end() {System.out.println("执行完成，end结束");}}public class Test021_Basic {public static void main(String[] args) {//1.接口不能实例化对象，下面一行编译报错//IAction ic = new IAction();//2.接口引用 指向实现类对象IAction ac = new ActionImpl();//3.接口数据成员访问测试System.out.println(IAction.NUM);System.out.println(ac.NUM);System.out.println("-------------");//4.通过接口引用 调用 重写方法（多态体现）ac.start();ac.end();}}注意事项：
在类和接口的实现关系中，可以使用多态 ，因为类和接口的实现关系，可理解为继承的一种形式。
一个类可以同时实现多个接口 ，但需要把多个接口的抽象方法全部重写（后面案例中具体演示）。
3 接口继承
Java中，类和类之间是单继承关系，接口和接口之间是多继承
接口继承格式：
[修饰符] interface 子接口 extends 父接口1,父接口2... { //新增成员或抽象方法}例如：
interface Runable {void run();}interface Flyable {void fly();}//接口多继承interface Action extends Runable,Flyable {void sing();}4 综合案例
案例描述：
定义一个抽象父类Animal2，再定义两个接口IJumpAble跳火圈、ICycleAble骑自行车，最后定义一个猴子类Monkey，去继承Animal2，同时实现IJumpAble、ICycleAble，进行功能测试。
复杂实现类定义格式：
[修饰符] class 实现类 extends 父类 implements 接口名1, 接口名2, ... { 重写所有方法; }案例描述：
package com.briup.chap07.test;//定义抽象父类abstract class Animal2 {private String color;private int age;public Animal2() {}public Animal2(String color, int age) {this.color = color;this.age = age;}// 抽象方法public abstract void eat();public abstract void sleep();}//定义跳火圈接口interface IJumpAble { //默认修饰符为：public abstractvoid jump();}//定义骑自行车接口 interface ICycleAble {public abstract void cycle();}// 定义猴子类: 继承Animal类，同时实现ICycleAble、IJumpAble接口class Monkey extends Animal2 implements ICycleAble, IJumpAble {private String name; //自定义构造方法public Monkey() {} public Monkey(String color, int age, String name) {super(color, age);this.name = name;}//重写从父类继承的方法@Overridepublic void eat() {System.out.println("猴子" + name + " 喜欢吃大桃子");}@Overridepublic void sleep() {System.out.println("猴子" + name + " 喜欢在树上睡觉");}// 重写从接口获取的抽象方法@Overridepublic void cycle() {System.out.println("猴子 " + name + " 能够骑自行车");}@Overridepublic void jump() {System.out.println(name + " 能够跳火圈");}}//测试类public class Test024_Monkey {// 基本测试public static void main(String[] args) { //1.抽象类不能实例化对象，但可以定义引用指向子类对象Animal2 a = new Monkey("yellow", 2, "小悟空"); //2.借助抽象类引用，只能访问抽象类中具有的方法a.eat();a.sleep(); //下面两行编译报错【多态：编译看左边，运行看右边】 //a.jump(); //a.cycle(); System.out.println("****************");//3.用接口引用指向实现类对象ICycleAble c = new Monkey("yellow", 5, "马戏团小猴"); //4.借助接口引用调用接口中重写方法c.cycle(); //注意：接口引用类型 只能调用 接口中具备的方法【多态：编译看左边，运行看右边】//下面三行编译报错 //c.eat(); error//c.sleep(); error //c.jump();error System.out.println("****************"); //5.如果想要调用父类方法或其他接口方法，可以借助类型转换实现 //注意，一定要借助instanceof额外判断引用指向对象的类型if (c instanceof Monkey) {Monkey m = (Monkey) c;m.eat();m.sleep();} System.out.println("****************"); if (c instanceof IJumpAble) {IJumpAble j = (IJumpAble) c;j.jump();}}}运行效果：
注意事项：
**接口多态应用时，编译看左边，运行看右边 **
**即接口引用只能调用接口中包含的方法，成功调用的是重写以后的方法 **
5 类接口关系
类与类的关系
继承关系，只能单继承，但是可以多层继承
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系
继承关系，可以单继承，也可以多继承
2.6 接口新特性
1）JDK8新特性：接口可以包含静态方法和默认方法
案例如下：
package com.briup.chap07.test;//JDK8中接口 可以添加默认方法和static方法interface JDK8Action {// 接口中静态常量String OPS_MODE = "auto";// 接口中抽象方法void start();void stop(); //下面是JDK8新特性//默认方法public default void dFun() {System.out.println("in default fun() ...");} //静态方法public static void sFun() {System.out.println("in static fun() ...");}}class Demo01 implements JDK8Action {@Overridepublic void start() {System.out.println("重写start() ...");}@Overridepublic void stop() {System.out.println("重写stop() ...");}}public class Test026_JDK8 {public static void main(String[] args) {//1.接口引用指向实现类对象JDK8Action a = new Demo01();//2.调用实现类重写方法a.start();a.stop();//3.调用default方法a.dFun();//4.JDK8中接口可以定义static方法，只能通过接口名调用，但不能通过接口引用调用，也不能通过实现类名调用//a.sFun();编译报错 //Demo01.sFun(); 编译报错JDK8Action.sFun();}}注意事项：JDK8接口可以定义static方法，只能通过接口名调用
2）JDK9新特性：接口可以包含私有方法
案例如下：
package com.briup.chap07.test;//使用interface关键字来定义接口interface JDK9Action {// 接口中的静态常量String OPS_MODE = "auto";// 接口中的抽象方法void start(); //私有方法 jdk9以下报错private void run() { System.out.println("private run() ..."); }}class Demo02 implements JDK8Action {@Overridepublic void start() {System.out.println("重写start() ...");}}//测试类public class Test026_JDK9 {public static void main(String[] args) { //1.接口引用指向实现类对象JDK9Action a = new Demo02(); //2.调用实现类重写的抽象方法 a.start(); //3.调用接口private方法 a.run(); }}注意：测试上述案例需要用合适的JDK版本
7 常见面试题
接口和抽象类有什么区别？如何选择？
语法上两者区别：
定义方式：抽象类通过使用 abstract 关键字来定义，而接口使用 interface 关键字来定义数据成员：抽象类可以包含普通数据成员和static数据成员，而接口只能包含 static final 修饰的数据成员成员方法：抽象类可以包含具体的方法实现，而接口只能包含抽象方法，即没有方法体的方法声明构造函数：抽象类可以有构造函数，而接口不能有构造函数实现方式：一个类可以继承（extends）一个抽象类，而一个类可以实现（implements）多个接口多继承：Java不支持多继承，一个类只能继承一个抽象类，但可以实现多个接口设计理念区别：
同一个接口的不同的实现类之间，体现的是 like a 的关系 ，接口更加强调行为规范的定义，适用于多个类具有相同行为规范的情况。
例如：飞机具备飞翔的行为，鸟也具备飞翔的行为，此时我们就可以定义接口包含抽象方法fly(),然后让飞机和鸟分别去实现该接口。飞机 like a 鸟，因为它们都会fly()。
子类和抽象父类体现的是 is a 的关系 ，抽象类归根到底还是类，它比较特殊，不能被实例化，只能被继承。抽象类用于定义一种通用的模板或者规范，其中可包含了一些具体数据成员、方法实现和抽象方法声明。
例如：前面案例中的形状类Shape，它里面包含方法getArea()，但该方法功能不确定，所以定义成抽象方法，而包含了抽象方法的类Shape也必须被声明为抽象类。定义子类圆形类，其getArea()方法功能是明确的，则子类中重写方法。
结论：
如果仅仅要额外扩展已存在类的功能，则选择定义接口，让类去实现接口；如果需要创建一组相关的类，且这些类之间有一些共同的行为和属性，那么可以定义一个类作为这些类的父类。如果不想实例化父类对象，则可以把这个父类设置为抽象类。