第六章：接口

系列文章目录

---

---

前言

接口是更加抽象的类。

---

一、接口

usb插槽就是现实中的接口，厂家都遵守了统一的规定包括尺寸，排线等。这样的设计在java编程中也是大量存在的。

package com.hspedu.interface_;public interface UsbInterface { //接口//规定接口的相关方法,老师规定的.即规范...public void start();public void stop();
} package com.hspedu.interface_;public class Camera implements UsbInterface{//实现接口,就是把接口方法实现@Overridepublic void start() {System.out.println("相机开始工作...");} @Overridepublic void stop() {System.out.println("相机停止工作....");}
}package com.hspedu.interface_;//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {@Overridepublic void start() {System.out.println("手机开始工作...");} @Overridepublic void stop() {System.out.println("手机停止工作.....");}
}package com.hspedu.interface_;public class Interface01 {public static void main(String[] args) {//创建手机， 相机对象//Camera 实现了 UsbInterfaceCamera camera = new Camera();//Phone 实现了 UsbInterfacePhone phone = new Phone();//创建计算机Computer computer = new Computer();computer.work(phone);//把手机接入到计算机System.out.println("===============");computer.work(camera);//把相机接入到计算机}
}

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

//语法形式
interface 接口
{//属性//方法//比如：public void eat();
}class 类名 implements 接口
{//自己属性//自己方法//必须实现的接口的抽象方法
}

接口本质
接口就是更加抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【JDK7.0】
接口体现了程序设计的多态和高内聚低耦合的设计思想
【JDK8.0】后接口可以有静态方法，成员方法，也就是说接口中可以有方法的具体实现

package com.hspedu.interface_;public interface DBInterface { //项目经理public void connect();//连接方法public void close();//关闭连接
} package com.hspedu.interface_;//A 程序
public class MysqlDB implements DBInterface {@Overridepublic void connect() {System.out.println("连接 mysql");} @Overridepublic void close() {System.out.println("关闭 mysql");}
}package com.hspedu.interface_;//B 程序员连接 Oracle
public class OracleDB implements DBInterface{@Overridepublic void connect() {System.out.println("连接 oracle");} @Overridepublic void close() {System.out.println("关闭 oracle");}
} package com.hspedu.interface_;public class Interface03 {public static void main(String[] args) {MysqlDB mysqlDB = new MysqlDB();t(mysqlDB);OracleDB oracleDB = new OracleDB();t(oracleDB);} public static void t(DBInterface db) {db.connect();db.close();}
}

接口使用细则part1
1）接口不能被实例化
2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
3）一个普通类实现接口，就必须将该接口的所有方法都实现
4）抽象类实现接口，可以不用实现接口的方法

package com.hspedu.interface_;public class InterfaceDetail01 {public static void main(String[] args) {//new IA();}
} //1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法， 可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
//4.抽象类去实现接口时， 可以不实现接口的抽象方法interface IA {void say();//修饰符 public protected 默认 privatevoid hi();
} class Cat implements IA{@Overridepublic void say() {} @Overridepublic void hi() {}
} abstract class Tiger implements IA {
}

接口使用细则part2
5）一个类可以同时实现多个接口
6）接口中的属性，只能是final的，而且是public static final 修饰符。比如：int a = 1；实际上是public static final int a = 1；(必须初始化)
7）接口中的属性的访问形式：接口名.属性名
8）接口不能继承其他类，但可以继承多个别的接口
9）接口的修饰符 只能是public和默认，这点和类的修饰符是一样的

package com.hspedu.interface_;public class InterfaceDetail02 {public static void main(String[] args) {//老韩证明 接口中的属性,是 public static finalSystem.out.println(IB.n1);//说明 n1 就是 static//IB.n1 = 30; 说明 n1 是 final}
} interface IB {//接口中的属性,只能是 final 的， 而且是 public static final 修饰符int n1 = 10; //等价 public static final int n1 = 10;void hi();
} interface IC {void say();
}//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {} //接口的修饰符 只能是 public 和默认， 这点和类的修饰符是一样的
interface IE{}//一个类同时可以实现多个接口
class Pig implements IB,IC {@Overridepublic void hi() {} @Overridepublic void say() {}
}

二、实现接口与继承类

实现接口和继承类的区别
当子类继承了父类，就自动的拥有父类的功能，解决代码的复用性和可维护性
如果子类需要扩展功能，可以通过实现接口的方式扩展，设计好各种规范（方法），让其它类去实现这些方法，即更加灵活
接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足 like - a的关系
可以理解实现接口是对java单继承机制的一种补充，接口在一定程度上实现代码解耦，即接口规范性+动态绑定机制

package com.hspedu.interface_;public class ExtendsVsInterface {public static void main(String[] args) {LittleMonkey wuKong = new LittleMonkey("悟空");wuKong.climbing();wuKong.swimming();wuKong.flying();}
} //猴子
class Monkey {private String name;public Monkey(String name) {this.name = name;} public void climbing() {System.out.println(name + " 会爬树...");} public String getName() {return name;}
} //接口
interface Fishable {void swimming();
} 
interface Birdable {void flying();
} //继承
//小结: 当子类继承了父类， 就自动的拥有父类的功能
// 如果子类需要扩展功能， 可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {public LittleMonkey(String name) {super(name);} @Overridepublic void swimming() {System.out.println(getName() + " 通过学习， 可以像鱼儿一样游泳...");} @Overridepublic void flying() {System.out.println(getName() + " 通过学习， 可以像鸟儿一样飞翔...");}}

三、接口的多态特性

接口的多态性
多态参数：接口引用可以指向实现了接口的类的对象
多态数组：数组引用可以指向实现了接口的类的对象
多态传递：接口继承父接口可以被接口实现并实现接口的类的引用

package com.hspedu.interface_;public class InterfacePolyParameter {public static void main(String[] args) {//接口的多态体现//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例IF if01 = new Monster();if01 = new Car();//继承体现的多态//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例AAA a = new BBB();a = new CCC();}
}interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {} 
class BBB extends AAA {}
class CCC extends AAA {}

package com.hspedu.interface_;public class InterfacePolyArr {public static void main(String[] args) {//多态数组 -> 接口类型数组Usb[] usbs = new Usb[2];usbs[0] = new Phone_();usbs[1] = new Camera_();/*给 Usb 数组中， 存放 Phone 和 相机对象， Phone 类还有一个特有的方法 call（） ，请遍历 Usb 数组， 如果是 Phone 对象， 除了调用 Usb 接口定义的方法外，还需要调用 Phone 特有方法 call*/for(int i = 0; i < usbs.length; i++) {usbs[i].work();//动态绑定..//和前面一样， 我们仍然需要进行类型的向下转型if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_((Phone_) usbs[i]).call();}}}
} interface Usb{void work();
} class Phone_ implements Usb {public void call() {System.out.println("手机可以打电话...");} @Overridepublic void work() {System.out.println("手机工作中...");}
} class Camera_ implements Usb {@Overridepublic void work() {System.out.println("相机工作中...");}
}

ackage com.hspedu.interface_;/**
* 演示多态传递现象
*/
public class InterfacePolyPass {public static void main(String[] args) {//接口类型的变量可以指向， 实现了该接口的类的对象实例IG ig = new Teacher();//如果 IG 继承了 IH 接口， 而 Teacher 类实现了 IG 接口//那么， 实际上就相当于 Teacher 类也实现了 IH 接口.//这就是所谓的 接口多态传递现象.IH ih = new Teacher();}
} 
interface IH {void hi();
} 
interface IG extends IH{ }class Teacher implements IG {@Overridepublic void hi() {}
}

---

总结

接口的使用更多是对类继承的一种补充。