Java学习笔记day10

新手小白6

已于 2022-10-08 21:17:28 修改

阅读量199

点赞数

分类专栏： Java学习记录文章标签： java 学习 jvm

于 2022-10-08 21:08:28 首次发布

本文链接：https://blog.csdn.net/kouzai8880/article/details/127216087

版权

Java学习记录专栏收录该内容

41 篇文章 0 订阅

订阅专栏

接口

理解

微观上来看是一种功能
	如: 
		1.鸟会飞，飞机会飞，所以飞是一个功能
		2.打火机可以点火，火柴可以点火，煤气灶可以点火，火把可以点火，点火是一种功能
		
宏观上来看是一种规则
	如: 
		电脑上提供USB接口，只有符合该接口的要求，就可以与电脑连接

如何定义一个接口

语法: 
	访问权限修饰符 interface 接口名{
	
	}
注意: 
	可以定义公共静态常量，因为接口中的属性默认使用public static final修饰
	可以定义公共静态方法，接口中的方法默认使用public修饰
	可以定义公共抽象方法，接口中的抽象方法默认使用public abstract修饰
	jdk1.8以后可以定义default修饰的方法，如: 
		default 返回值类型 方法名(形参列表){
			方法体
		}
	(default修饰的方法相当于public修饰的方法，可以这么理解)
	
	不能定义代码块与静态代码块
	不能定义构造函数，因为接口不能创建对象
	不能定义普通属性
	不能定义普通方法

如何使用接口

类使用接口: 实现
	语法: 
		访问权限修饰符 class 类名 extends 父类名 implements 接口名1, 接口名2, 接口名3, ...{
		
		}
	注意: 
		一个类只能继承一个直接父类(单继承)
		一个类可以实现多个接口(多实现)
		一个子类对象可以转换为多个父类或接口对象
	优点: 
		1.接口可以多实现，代码的扩展性得到提升
		2.接口可以多实现，所以一个实现了多个接口的子类对象，可以转换为多个接口对象
		
接口使用接口: 继承
	语法: 
		访问权限修饰符 interface 接口名 extends 父接口名1, 父接口名2...{
		
		}
	注意: 
		一个接口可以继承于多个接口
		子接口可以继承父接口的公共静态常量
		子接口可以继承父接口default修饰的方法
		子接口可以继承父接口的抽象方法
		
		子接口不能继承父接口的公共静态方法
		继承的多个接口中有相同的default的方法，此时子接口要重写该方法
		继承的多个接口中有相同的属性，此时会出现冲突，要避免此种情况
		继承的多个接口中有相同的抽象方法，此时不需要处理，因为抽象方法要么被重写要么实现该接口的类也是抽象类

特殊使用情况

常量接口

interface Utils{
	String ERROR_01 = "请检查您的网络";
	String ERROR_02 = "账号密码不匹配";
	String ERROR_03 = "账号被封等待解封";
	String ERROR_04 = "账号不存在";
	String ERROR_05 = "账号存在被盗风险";
	String ERROR_06 = "验证码错误";
	...
}
interface PathUtisl{
	//String PATH_CS = "https://127.0.0.1:8080/xxx";
	String PATH_CS = "https://www.baidu.com/xxx";
}
概念: 只定义常量的接口称为常量接口

接口回调

回: 去之后，才有回的概念
总结: 
	1.创建接口对象
	2.传递接口对象
	3.调用某方法时，该方法中使用传递的接口对象调用接口方法
案例: 点击登录按钮显示登陆成功

案例: 台灯打开后，灯泡发光
	分析: 
		台灯
		灯泡
	类或接口
		台灯类
		class Lamp{
			private LightInterface light;
			public void setLightInterface(LightInterface lightInterface){
				this.light = lightInterface;
			}
			public void on(){
				light.light();
			}
		}
		发光接口
		public interface LightInterface{
			void light();
		}
		灯泡类实现发光接口
		public class Buble implements LightInterface{
			public void light(){
				System.out.println("发光")
			}
		}
		环境类(测试类): 
			创建灯泡对象
				Buble b = new Buble();
			创建台灯对象
				Lamp l = new Lamp();
			给台灯安装发光的接口对象(安装灯泡)
				l.setLightInterface(b);
			打开台灯
				l.on();
		
案例: 电脑上提供三个USB插口,可以连接鼠标,键盘,U盘

接口与抽象类的区别

接口: 
	概念: 功能或者规则
	使用: 
		接口使用接口，多继承(extends)
		类使用接口，多实现(implements)
		注意: 一个类可以实现多个接口
	可以定义: 
		公共静态常量
		公共静态方法
		公共抽象方法
		default修饰的方法
	不能直接创建对象，如果想创建对象必须创建其子类对象，然后将其转换为父类(父接口)对象
	会生成class文件
	
抽象类
	概念: 一类事物的描述概念
	使用: 
		被别的类继承
		注意: 一个类只能直接继承于一个类
	可以定义: 
		属性
		构造函数
		方法
		抽象方法
		代码块
	不能直接创建对象，如果想创建对象必须创建其子对象，然后将其转换为父类(父接口)对象
	会生成class文件

练习

1.鸟会飞，飞机会飞，超人会飞
请定义一个飞的接口，并让鸟，飞机，超人实现该接口，并测试
2.让超人拥有隐身的功能，使用接口实现

package demo01;
//定义飞的接口
public interface FlyInterface {
	void fly();
}

package demo01;
//定义隐身接口
public interface Invisible {
	void invisible();
}

package demo01;
//定义鸟类
public class Bird implements FlyInterface{

	@Override
	public void fly() {
		System.out.println("鸟飞");
	}

}

package demo01;
//定义飞机类
public class Plane implements FlyInterface{

	@Override
	public void fly() {
		System.out.println("飞机飞");
	}

}

package demo01;
//定义超人类
public class Superman implements FlyInterface, Invisible{

	@Override
	public void fly() {
		System.out.println("超人会飞");
	}

	@Override
	public void invisible() {
		System.out.println("超人会隐身");
	}
			
}

package demo01;
//定义测试类
public class Test {
	public static void main(String[] args) {
		test(new Bird());
		test(new Plane());
		test(new Superman());
		new Superman().invisible();
	}
	
	public static void test(FlyInterface fly) {
		fly.fly();
	}
}

运行结果

3.接口回调案例: 点击登录按钮显示登陆成功

package demo02;

public interface OnClickListenerInterface {
	void click();
}

package demo02;

public class OnClickListener implements OnClickListenerInterface{

	@Override
	public void click() {
		System.out.println("登录按钮被点击, 登陆成功");
	}

}

package demo02;

public class Button {
	private String name;
	private OnClickListenerInterface listener;

	public Button() {
		
	}

	public Button(String name, OnClickListenerInterface listener) {
		this.name = name;
		this.listener = listener;
	}
	
	public void setListener(OnClickListenerInterface listener) {
		this.listener = listener;
	}
	
	public void down() {
		listener.click();
	}
	
}

package demo02;

public class Test {
	public static void main(String[] args) {
		Button btn = new Button("登录", null);
		OnClickListener listener = new OnClickListener();
		btn.setListener(listener);
		btn.down();
	}
}

运行结果

4.接口回调案例: 电脑上提供三个USB插口,可以连接鼠标,键盘,U盘

package demo03;
//定义USB接口
public interface USBInterface {
	void close();
	void conn();
}

package demo03;
//定义鼠标类
public class Mouse implements USBInterface{

	@Override
	public void close() {
		System.out.println("鼠标断开连接");
	}

	@Override
	public void conn() {
		System.out.println("鼠标连接成功");
	}

}

package demo03;
//定义键盘类
public class Keyboard implements USBInterface{

	@Override
	public void close() {
		System.out.println("键盘断开连接");
	}

	@Override
	public void conn() {
		System.out.println("键盘连接成功");
	}

}

package demo03;
//定义U盘类
public class UPan implements USBInterface{

	@Override
	public void close() {
		System.out.println("U盘断开连接");
	}

	@Override
	public void conn() {
		System.out.println("U盘连接成功");
	}

}

package demo03;
//定义电脑类
public class Computer {
	private USBInterface usb01;
	private USBInterface usb02;
	private USBInterface usb03;
	
	public Computer() {
		
	}
	
	public void setUsb01(USBInterface usb) {
		if(usb01 != null) {
			usb01.close();
		}
		usb01 = usb;
		usb01.conn();
	}
	
	public void closeUsb01() {
		if(usb01 != null) {
			usb01.close();
			usb01 = null;
		}
	}
	
	public void setUsb02(USBInterface usb) {
		if(usb02 != null) {
			usb02.close();
		}
		usb02 = usb;
		usb02.conn();
	}
	
	public void closeUsb02() {
		if(usb02 != null) {
			usb02.close();
			usb02 = null;
		}
	}
	
	public void setUsb03(USBInterface usb) {
		if(usb03 != null) {
			usb03.close();
		}
		usb03 = usb;
		usb03.conn();
	}
	
	public void closeUsb03() {
		if(usb03 != null) {
			usb03.close();
			usb03 = null;
		}
	}
	
	//开机
	public void open() {
		System.out.println("电脑正在开机");
		if(usb01 != null) {
			usb01.conn();
		}
		if(usb02 != null) {
			usb02.conn();
		}
		if(usb03 != null) {
			usb03.conn();
		}
		System.out.println("电脑开机成功");
	}
	
	//关机
	public void close() {
		System.out.println("电脑正在关机");
		System.out.println("电脑关机成功");
	}
}

package demo03;
//定义测试类
public class Test {
	public static void main(String[] args) {
		Computer computer = new Computer();
		Mouse mouse = new Mouse();
		Keyboard keyboard = new Keyboard();
		UPan uPan = new UPan();
		
		computer.open();
		computer.setUsb01(mouse);
		computer.setUsb02(keyboard);
//		computer.setUsb01(uPan);
		computer.closeUsb01();
		computer.setUsb01(uPan);
		computer.close();
		System.out.println("---------------");
		computer.open();
	}
}