第六章:接口

系列文章目录


文章目录


前言

接口是更加抽象的类。


一、接口

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

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

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

java 复制代码
//语法形式
interface 接口
{
	//属性
	//方法
}

class 类名 implements 接口
{
	//自己属性
	//自己方法
	//必须实现的接口的抽象方法
}
接口本质
接口就是更加抽象的类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体【JDK7.0】
接口体现了程序设计的多态和高内聚低耦合的设计思想
【JDK8.0】后接口可以有静态方法,成员方法,也就是说接口中可以有方法的具体实现
java 复制代码
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();
	}
}
接口使用细则part1
1)接口不能被实例化
2)接口中所有的方法是public方法,接口中抽象方法,可以不用abstract修饰
3)一个普通类实现接口,就必须将该接口的所有方法都实现
4)抽象类实现接口,可以不用实现接口的方法
java 复制代码
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 {
}
接口使用细则part2
5)一个类可以同时实现多个接口
6)接口中的属性,只能是final的,而且是public static final 修饰符。比如:int a = 1;实际上是public static final int a = 1;(必须初始化)
7)接口中的属性的访问形式:接口名.属性名
8)接口不能继承其他类,但可以继承多个别的接口
9)接口的修饰符 只能是public和默认,这点和类的修饰符是一样的
java 复制代码
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() {}
}

二、实现接口与继承类

实现接口和继承类的区别
当子类继承了父类,就自动的拥有父类的功能,解决代码的复用性和可维护性
如果子类需要扩展功能,可以通过实现接口的方式扩展,设计好各种规范(方法),让其它类去实现这些方法,即更加灵活
接口比继承更加灵活,继承是满足is - a的关系,而接口只需满足 like - a的关系
可以理解实现接口是对java单继承机制的一种补充,接口在一定程度上实现代码解耦,即接口规范性+动态绑定机制
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() + " 通过学习, 可以像鸟儿一样飞翔...");
	}
	
}

三、接口的多态特性

接口的多态性
多态参数:接口引用可以指向实现了接口的类的对象
多态数组:数组引用可以指向实现了接口的类的对象
多态传递:接口继承父接口可以被接口实现并实现接口的类的引用
java 复制代码
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 {}
java 复制代码
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("相机工作中...");
	}
}
java 复制代码
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 小时前
Jpa使用union all
java·spring boot·后端
用户3721574261351 小时前
Java 实现 Excel 与 TXT 文本高效互转
java
浮游本尊2 小时前
Java学习第22天 - 云原生与容器化
java
渣哥4 小时前
原来 Java 里线程安全集合有这么多种
java
间彧4 小时前
Spring Boot集成Spring Security完整指南
java
间彧5 小时前
Spring Secutiy基本原理及工作流程
java
Java水解6 小时前
JAVA经典面试题附答案(持续更新版)
java·后端·面试
洛小豆8 小时前
在Java中,Integer.parseInt和Integer.valueOf有什么区别
java·后端·面试
前端小张同学8 小时前
服务器上如何搭建jenkins 服务CI/CD😎😎
java·后端
ytadpole8 小时前
Spring Cloud Gateway:一次不规范 URL 引发的路由转发404问题排查
java·后端