Java 接口

目录

1.为什么有接口

2.接口快速入门

3.基本介绍

4.深入讨论

5.注意事项和细节

6.练习题(1)

7.实现接口 vs 继承类

8.接口的多态特性

9.练习题(2)

1.为什么有接口

2.接口快速入门

这样的设计需求在java编程/php/.net/go中也是会大量存在的,一个程序就是一个世界,在现实世界存在的情况，在程序中也会出现。我们用程序来模拟一下。

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

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现
	
	@Override
	public void start() {
		System.out.println("相机开始工作...");
	}

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

//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
	@Override
	public void start() {
		System.out.println("手机开始工作...");
	}
	@Override
	public void stop() {
		System.out.println("手机停止工作.....");
	}
}

public class Computer {
	//编写一个方法计算机工作
	public void work (UsbInterface usbInterface) {//通过接口来调用方法
		usbInterface.start();
		usbInterface.stop();
	}
}

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);//把相机接入到计算机
	}
}

3.基本介绍

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

interface 接口名{
	//属性
	//方法（1.抽象方法 2.默认实现方法 3.静态方法）
}

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

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。

接口体现了程序设计的多态和高内聚低偶合的设计思想。

特别说明：Jdk8.0后接口类可以有静态方法，默认方法（需要使用default关键字），也就是说接口中可以有方法的具体实现★

4.深入讨论

 

代码:
public interface DBInterface { //项目经理
	public void connect();//连接方法
	public void close();//关闭连接
}

//A 程序
public class MysqlDB implements DBInterface {
	@Override
	public void connect() {
		System.out.println("连接 mysql");
	}
	@Override
	public void close() {
		System.out.println("关闭 mysql");
	}
}

//B 程序员连接 Oracle
public class OracleDB implements DBInterface{
	@Override
	public void connect() {
		System.out.println("连接 oracle");
	}
	@Override
	public void close() {
		System.out.println("关闭 oracle");
	}
}

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();
	}
}

5.注意事项和细节

1. 接口不能被实例化
2. 接口中所有的方法是 public方法,接口中抽象方法，可以不用abstract修饰 图示: void aaa(); 实际上是 abstract void aa( );
3. 一个普通类实现接口,就必须将该接口的所有方法都实现。
4. 抽象类实现接口，可以不用实现接口的方法。
5. 一个类同时可以实现多个接口[举例]——>InterfaceDetail02.java
6. 接口中的属性,只能是final的，而且是 public static final修饰符。【比如:int a=1;实际上是 public static final int a=1; (必须初始化)】
7. 接口中属性的访问形式:接口名.属性名
8. 接口不能继承其它的类,但是可以继承多个别的接口[举例]
   interface A extends B,C
9. 接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的。

代码:
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 {
}

代码
public class InterfaceDetail02 {
	public static void main(String[] args) {
		//证明 接口中的属性,是 public static final
		System.out.println(IB.n1);//说明 n1 就是 static
		[//IB.n1](notion://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() {
	}
}

6.练习题(1)

InterfaceExercise01.java 2min
interface A{
	int a=23;//等价public static final int a = 23;
}
class B implements A//正确
main中:
Bb=new B();//ok
System.out.println(b.a); //23
System.out.println(A.a); //23
System.out.println(B.a);//23

7.实现接口 vs 继承类

 

代码:
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() + " 通过学习，可以像鸟儿一样飞翔...");
	}
}

• 接口和继承解决的问题不同
• 继承的价值主要在于：解决代码的复用性和可维护性。
• 接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活.. ·接口比继承更加灵活
• 接口比继承更加灵活，继承是满足is- a的关系，而接口只需满足 like - a的关系。接口在一定程度上实现代码解耦【即：接口规范性+动态绑定机制】（解耦就是让代码的功能更独立，减少依赖性）

8.接口的多态特性

代码
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 {}

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("相机工作中...");
	}
}

/**演示多态传递现象
*/
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() {
	}
}

9.练习题(2)

public class InterfaceExercise02 {
	public static void main(String[] args) {
	}
}

interface A {
	int x = 0;
} //想到 等价 public static final int x = 0;

class B {
	int x = 1;
} //普通属性

class C extends B implements A {
	public void pX() {
		//System.out.println(x); //错误，原因不明确 x
		//可以明确的指定 x
		//访问接口的 x 就使用 A.x
		//访问父类的 x 就使用 super.x
		System.out.println(A.x + " " + super.x);
	}
	public static void main(String[] args) {
		new C().pX();
	}
}