第六章：接口-摩杜云开发者社区

前言接口是更加抽象的类。

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

package com.hspedu.interface_;

public interface UsbInterface { //接口 //规定接口的相关方法,老师规定的.即规范... public void start(); public void stop(); }

package com.hspedu.interface_;

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现

@Override
public void start() {
	System.out.println("相机开始工作...");
} 

@Override
public void stop() {
	System.out.println("相机停止工作....");
}

}

package com.hspedu.interface_;

//Phone 类实现 UsbInterface //解读 1. 即 Phone 类需要实现 UsbInterface 接口规定/声明的方法 public class Phone implements UsbInterface {

@Override
public void start() {
	System.out.println("手机开始工作...");
} 

@Override
public void stop() {
	System.out.println("手机停止工作.....");
}

}

package com.hspedu.interface_;

public class Interface01 { public static void main(String[] args) { //创建手机，相机对象 //Camera 实现了 UsbInterface Camera camera = new Camera(); //Phone 实现了 UsbInterface Phone phone = new Phone(); //创建计算机 Computer computer = new Computer(); computer.work(phone);//把手机接入到计算机 System.out.println("==============="); computer.work(camera);//把相机接入到计算机 } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

//语法形式 interface 接口 { //属性 //方法 }

class 类名 implements 接口 { //自己属性 //自己方法 //必须实现的接口的抽象方法 }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 接口本质接口就是更加抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【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 { @Override public void connect() { System.out.println("连接 mysql"); } @Override public void close() { System.out.println("关闭 mysql"); } }

package com.hspedu.interface_;

//B 程序员连接 Oracle public class OracleDB implements DBInterface{ @Override public void connect() { System.out.println("连接 oracle"); } @Override public 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(); } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 接口使用细则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 默认 private void hi(); }

class Cat implements IA{ @Override public void say() {} @Override public void hi() {} }

abstract class Tiger implements IA { }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 接口使用细则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 final System.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 { @Override public void hi() {} @Override public void say() {} }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 二、实现接口与继承类实现接口和继承类的区别当子类继承了父类，就自动的拥有父类的功能，解决代码的复用性和可维护性如果子类需要扩展功能，可以通过实现接口的方式扩展，设计好各种规范（方法），让其它类去实现这些方法，即更加灵活接口比继承更加灵活，继承是满足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);
} 

@Override
public void swimming() {
	System.out.println(getName() + " 通过学习， 可以像鱼儿一样游泳...");
} 

@Override
public void flying() {
	System.out.println(getName() + " 通过学习， 可以像鸟儿一样飞翔...");
}

}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 三、接口的多态特性接口的多态性多态参数：接口引用可以指向实现了接口的类的对象多态数组：数组引用可以指向实现了接口的类的对象多态传递：接口继承父接口可以被接口实现并实现接口的类的引用 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 {}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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("手机可以打电话..."); } @Override public void work() { System.out.println("手机工作中..."); } }

class Camera_ implements Usb { @Override public void work() { System.out.println("相机工作中..."); } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

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 { @Override public void hi() {} }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 总结接口的使用更多是对类继承的一种补充。