Java接口

Java接口概述

计算机中的接口有哪些? USB接口 , VGA接口,  耳机接口,  电源接口, HDMI高清接口,  Type-C接口, Thunder接口。

计算机通过这些接口可以连接不同的外设, 扩展了计算机的功能 , 计算机实现了某个接口,就具备了连接这个接口设备的功能, 没有实现该接口就不具备该功能。

计算机中有USB插槽, 不管是键盘/鼠标/硬盘/打印机,只要有USB插头就可以连接到电脑上, 这些设备是不同厂商生产的, 它们都遵循USB协议。

Java程序中的接口是用来扩展类的功能的,可以把接口理解为功能的封装, Java中的接口也可以理解为一个操作规范(协议)。

Java接口定义与实现

1.Java接口定义的语法:

[修饰符]   interface  接口名 {

接口中的方法默认使用public abstract修饰

接口中的字段默认使用 public static final修饰

接口中可以定义public static 静态方法

定义public  default方法

}

2.Java接口的使用

[修饰符]  class  类名  implements  接口{

需要重写接口的抽象方法

package com.wkcto.chapter01.interfaces.demo01;
/**
 * 定义飞行接口
 * 		封装飞行功能
 * @author 蛙课网
 *
 */
public interface Flyable {
	//接口中的方法默认使用public abstract修饰
	void fly();
	
}

package com.wkcto.chapter01.interfaces.demo01;
/**
 * 定义鸟类
 * 	一个类实现了接口,需要重写接口中抽象方法
 * 
 * @author 蛙课网
 *
 */
public class Bird implements Flyable {

	@Override
	public void fly() {
		System.out.println("小鸟在天空中自由飞翔");
	}

}

练习：定义接口封装游泳功能, 鱼会游泳, 小狗会游泳, 人会游泳。

Java接口多态

package com.wkcto.chapter01.interfaces.demo01;
/**
 * 1) 接口是一种引用数据类型,可以定义变量,但是接口不能实例化对象, 接口引用可以赋值实现类对象
 * 2) 接口多态 , 通过接口引用调用接口中抽象方法,实际上执行的是实现类对象的方法
 * 		接口存在的意义就是为了实现多态.
 * 
 * @author 蛙课网
 *
 */
public class Test {

	public static void main(String[] args) {
		//1)接口定义变量
		Flyable flyable ;
		//2)接口不能实例化对象
//		flyable = new Flyable(); 		//Cannot instantiate the type Flyable
		//3)接口引用可以赋值实现类对象
		flyable = new Bird();
		flyable.fly();
		
		flyable = new Plane();
		flyable.fly();
		
	}

}

package com.wkcto.chapter01.interfaces.demo01;
/**
 * 测试弹弓可以把能飞的物体给射出去
 * @author 蛙课网
 *
 */
public class Test02 {

	public static void main(String[] args) {
		//创建弹弓对象
		Slingshot slingshot = new Slingshot();
		//创建鸟对象
		Bird bird = new Bird();
		slingshot.shoot(bird);
		
		//创建飞机对象
		Plane plane = new Plane();
		slingshot.shoot(plane);
		
	}

}

package com.wkcto.chapter01.interfaces.demo01;
/**
 * 弹弓类
 * 		可以把任何能飞物体给弹射出去
 * 
 * 经常, 把接口的引用作为方法的形参, 在调用方法时,传递接口实现类的对象
 * @author 蛙课网
 *
 */
public class Slingshot {
	//可以把任何能飞物体给弹射出去, 如果这个物体实现了Flyable飞行接口就能飞
	public void shoot( Flyable flyable ) {
		//实际上是物体 在飞
		flyable.fly();
	}
}

练习：游泳馆只接收会游泳的动物来游泳。

Java接口说明

1.类实现了某个接口,需要重写接口中的抽象方法,就具备了接口中定义的功能; 如果一个类实现了接口,没有重写接口中所有的抽象方法,这个类需要定义为抽象类。

2.一个类可以实现多个接口, 接口名之间使用逗号分隔, 这个类需要重写所有接口中所有的抽象方法。

3.接口也能继承,并且支持多继承, 在子接口中可以扩展接口的功能。

4.接口的内容在JDK8中, 只包含四部分: public abstract默认的方法, public static final默认的字段, public static静态方法, public default方法。

Java抽象类与接口的异同点

相同点

1.都可以定义抽象方法

2.都不能实例化对象

3.接口/抽象类的抽象方法都需要被重写

4.接口/抽象类中都可以定义 public static final字段, public static静态方法

不同点

1.意义不同

抽象类对类进行更高层级的抽象

接口是对功能的封装

2.定义方式不同

抽象类使用 abstract  class定义

接口使用interface定义

3.内容不同

抽象类中除了可以定义抽象方法外, 还可以定义实例变量/实例方法/静态变量/静态方法,构造方法等普通类所有的成员。

接口中除了抽象方法外, 还可以定义public static final字段, public static方法,public default方法 。

抽象类有构造方法, 接口没有构造方法; 接口中可以使用default修饰方法，抽象类不能使用default修饰方法。

4.使用方式不同

抽象类一般作为父类存在, 需要子类通过extends继承。

接口需要通过类implements实现。

5.继承

类只支持单继承, 接口支持多继承

6.应用场景不同

如果仅仅是为了扩展类的功能,优先选择接口;

如果除了功能外,还需要保存不同的数据,选择抽象类,  抽象类中的抽象方法,需要在子类中重写, 抽象类可以约束所有的子类都具有某个功能。

Java接口的应用

1.接口就是功能的封装

如在Flyable接口中封装了fly()飞行功能, 如果类实现了Flyable接口,需要重写fly()方法,就扩展了类的功能。

如系统定义的Comparable接口, 封装了比较两个对象的功能, 如果一个类想要比较两个对象的大小, 可以实现Comparable接口。

package com.wkcto.chapter01.interfaces.demo03;
/**
 * 定义Person类,
 * 	想要让Person类的对象具有比较大小的功能, 可以通过实现Comparable接口完成这个需求
 * 	Comparable接口后面的<T>是一个泛型 ,泛型就是把数据类型作为参数
 * 		通过Comparable后面的泛型指定比较对象的数据类型
 * @author 蛙课网
 *
 */
public class Person implements Comparable<Person> {
	String name;
	int age;
	int height;
	
	/**
	 * 重写接口的抽象方法, 指定比较规则
	 * 如果当前对象比参数o对象大就返回正数,  如果当前对象小于参数对象返回负数, 如果两个对象相等返回0
	 */
	@Override
	public int compareTo(Person o) {
		//在该方法中,指定比较规则,根据年龄比较
		return this.age - o.age;
	}

	public Person(String name, int age, int height) {
		super();
		this.name = name;
		this.age = age;
		this.height = height;
	}

	
}

2.接口可以理解为一组操作规范(一个协议)

百度新闻包含首页/体育/游戏/女人/汽车等模块, 不管哪个模块都有添加新闻,删除新闻,修改新闻,查询新闻. 可以把这些功能定义在一个接口中, 不同的模块通过实现这个接口来统一他们的操作。

提倡面向接口的编程

1.接口的使用比较灵活, 一个类在继承父类的同时,可以实现多个接口

描述打工的学生, 打工的学生既有学生的特点,又有工人的特征,如果允许类的多继承的话,可以直接让打工的学生同时继承学生类与工人类。

Java不允许多继承, 可以让打工的学生继承学生类, 把打工这个操作定义为接口, 打工的学生实现打工接口。

描述了打工的学生,从某种程度上,还能解决类的多继承问题

package com.wkcto.chapter01.interfaces.demo04;
/**
 * 定义学生类,作为父类
 * @author 蛙课网
 *
 */
public class Student {
	String name;
	
	public void study() {
		System.out.println("学生的本职工作是学习");
	}
}

package com.wkcto.chapter01.interfaces.demo04;
/**
 * 定义工作接口
 * @author 蛙课网
 *
 */
public interface Workable {
	void  work();
}

package com.wkcto.chapter01.interfaces.demo04;
/**
 * 打工的学生类
 * 		在继承Student类的同时,实现Workable接口
 * @author 蛙课网
 *
 */
public class PartTimeStudent extends Student implements Workable, Singable {

	//重写接口中的抽象方法
	@Override
	public void work() {
		System.out.println("兼职服务员,日结,工资800~1500");
	}

	@Override
	public void sing() {
		System.out.println("学生参加了中国好声音");
	}

}

练习1

1.描述带橡皮的铅笔,铅笔是一种笔,有擦除的功能。

2.接口比较容易扩展, 可以实现代码的可插拔

经常把接口的引用作为方法的形参, 在调用方法时,可以传递各种实现类对象

弹弓可以弹射能飞的物体, 游泳馆只接收会游泳的动物

3.接口可以使项目分层

一台计算机可以实现很多不同的接口, 接口比较灵活

计算机的USB插槽, 只要有USB插头的设备就可以连接到电脑上, 接口易扩展

生产电脑的厂商有联想/Dell/华硕等, 生产USB设备的也有很多不同的厂商, 使项目分层

在上图的模型中, 通过接口把项目简单的分为两层, 一个团队负责开发业务逻辑,一个小组负责开发数据库的操作及优化, 对开发人员的要求降低了；当数据库发生变化后,只需要由数据库的开发人员定义一个专门的操作数据库的类即可, 业务逻辑代码不需要更改。

package com.wkcto.chapter01.interfaces.demo05;
/**
 * 定义操作数据库的接口
 * 	在接口中定义一组操作数据库的规范
 * @author 蛙课网
 *
 */
public interface DaoService {
	void add();			//向数据库中添加数据
	void delete();		//删除数据
	void update();		//修改数据
	void list();		//显示所有数据
}

package com.wkcto.chapter01.interfaces.demo05;
/**
 * 业务逻辑模块1
 * 		操作数据库, 通过DaoService接口实现
 * @author 蛙课网
 *
 */
public class LogicModel1 {
	DaoService dao; 			//定义一个接口的引用
	
	//添加数据
	public void addData() {
		System.out.println("业务逻辑模块1, 需要向数据库中添加数据");
		dao.add();
	}
	
	//删除数据
	public void deleteData() {
		System.out.println("业务逻辑模块1, 需要从数据库中删除数据");
		dao.delete();
	}
	
	//修改数据
	public void updateData() {
		System.out.println("业务逻辑模块1, 需要在数据库中修改数据");
		dao.update();
	}
	
	//显示所有数据
	public void listAllData() {
		System.out.println("业务逻辑模块1, 需要从数据库中显示所有数据");
		dao.list();
	}
}

package com.wkcto.chapter01.interfaces.demo05;
/**
 * 定义一个操作MySQL数据库的类, 需要实现DaoServic接口
 * @author 蛙课网
 *
 */
public class MySqlDaoImpl implements DaoService {

	@Override
	public void add() {
		System.out.println("向MySQL数据库中添加数据");
	}

	@Override
	public void delete() {
		System.out.println("从MySQL数据库中删除数据");
	}

	@Override
	public void update() {
		System.out.println("在MySQL数据库中修改数据");
	}

	@Override
	public void list() {
		System.out.println("从MySQL数据库中查询所有数据");
	}

}

package com.wkcto.chapter01.interfaces.demo05;
/**
 * 测试业务逻辑模块操作数据库
 * @author 蛙课网
 *
 */
public class Test {

	public static void main(String[] args) {
		LogicModel1 model1 = new LogicModel1();
		
		//需要配置业务逻辑模块中dao接口引用 
//		model1.dao = new MySqlDaoImpl();
		//如果数据库由MySQL换为Oracle, 需要定义一个操作ORacle数据库的类,修改业务逻辑模块 dao接口的配置
		model1.dao = new OracleDaoImpl();		
		
		model1.addData();
		model1.updateData();
		model1.deleteData();
		model1.listAllData();
		
	}

}

练习2

模拟所有动物都可以使用自己的交流方式进行交流, 人说人话,狗说狗语。

package com.wkcto.chapter01.interfaces.demo06;
/**
 * 定义说话方式接口
 * @author 蛙课网
 *
 */
public interface Speakable {
	void speak(); 			//说话
}

package com.wkcto.chapter01.interfaces.demo06;
/**
 * 汪语
 * 	是一种说话方式
 * @author 蛙课网
 *
 */
public class WangWang implements Speakable {

	@Override
	public void speak() {
		System.out.println("汪汪汪~~~~");
	}

}

package com.wkcto.chapter01.interfaces.demo06;
/**
 * 定义动物类
 * 	每个 动物都有自己的说话方式
 * 	动物可以使用自己的说话方式进行交流
 * @author 蛙课网
 *
 */
public abstract class Animal {
	Speakable  speakable; 		//每个 动物都有自己的说话方式
	
	public Animal(Speakable speakable) {
		super();
		this.speakable = speakable;
	}

	//可以使用自己的说话方式进行交流
	public void talk() {
		speakable.speak();
	}
}

package com.wkcto.chapter01.interfaces.demo06;
/**
 * 小狗是一种动物
 * @author 蛙课网
 *
 */
public class Dog extends Animal {
	
	public Dog(Speakable speakable) {
		super(speakable);
	}

}

package com.wkcto.chapter01.interfaces.demo06;
/**
 * 测试每种动物可以使用自己的说话方式进行交流
 * @author 蛙课网
 *
 */
public class Test {

	public static void main(String[] args) {
		
		WangWang wangWang = new WangWang(); 		//小狗的说话方式 		
		Dog dahuang = new Dog(wangWang);			//在创建小狗对象时,需要指定它的说话方式
		dahuang.talk();
		
		MiaoMiao miaoMiao = new MiaoMiao();
		Cat mimi = new Cat(miaoMiao);
		mimi.talk();
		
		
	}

}