接口与多态

interface

接口里定义抽象方法

public interface InterFaceName {
	public abstract void method();
	//可以省略，默认前面带(public abstract)
	void method();
}

实现类，补充接口里抽象的内容

public class Animal implements InterFaceName {
	@Override
	public void method() {
	System.out.println("吃东西");
	}
}

创建对象

public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
	Animal a = new Animal();
// 调用实现后的方法
	a.method();
}
}

默认方法，可以解决接口升级的问题

• 在接口中新添加抽象方法，使用默认类,不然实现类会报错

public interface InterFaceName {
	public abstract void method();
//新添加的方法，改成默认方法,default
	public default void methodDeafult(){
	System.out.println("这是新添加的默认方法");
	}
}

public class Animal implements InterFaceName {
	@Override
	public void method() {
	System.out.println("吃东西");
	}
}

可以直接调用默认方法

public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
	Animal a = new Animal();
// 调用默认方法，输出+这是新添加的默认方法
	a.methodDeafult();
}
}

接口当中定义静态方法

public interface LiveAble {
public static void run(){
	System.out.println("跑起来~~~");
}
}

调用

public class InterfaceDemo {
public static void main(String[] args) {
// Animal.run(); // 【错误】无法继承方法,也无法调用
//静态方法最简单，接口名称（LiveAble）直接调用,静态跟对象没关系，直接用接口名称调用
	LiveAble.run(); //
}
}

接口常量的定义

public interface LiveAble {
//final 不可变
//public各部分都能用
//static跟对象没关，只与类有关
//不能变的量，要换成大写
	public static final int NUM=10;
}

访问

public class InterfaceDemo {
public static void main(String[] args) {
	System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
}
}

关系

• 一个类可以实现多个接口
• 接口与接口之间可以多继承，类与类之间是单继承
• 优先父类

当Fu与MyInterface有重复的默认方法，优先使用父类

 public class Zi extends Fu implements MyInterface 

interface A {
	public abstract void showA();
	public abstract void show();
}
interface B {
	public abstract void showB();
	public abstract void show();

public class C implements A,B{
@Override
	public void showA() {
	System.out.println("showA");
}
@Override
public void showB() {
	System.out.println("showB");
}
//两个接口中都有show()
@Override
public void show() {
	System.out.println("show");
}
}

多态

• 访问成员变量，等号左边用的是谁优先使用谁，没有则向上找
• new的是谁，调用的就是谁，因此父子类有相同函数时，先调用的是子类的方法。但父类没有的方法不会往下子类里面找

父类方法

public class Fu{
	int	num=10;
	public void method(){
		System.out.println("父类方法");
}
	public void methodFu(){
		System.out.println("父类方法");
}
}

子类方法

public class Zi{
	int	num=20;
	@override
	public void method(){
		System.out.println("子类方法");
}
}

使用多态

public class InterfaceDemo {
public static void main(String[] args) {
//左父右子
	Fu obj=new Zi();
	//new的是谁，调用的就是谁，因此调用的是**子类的方法**
	//访问方法，看右边
	obj.method();
	obj.methodFu();
	//输出的是父类=10
	System.out.println(obj.num);
}
}

应用场景

• Employee是固定的，若有新的身份，教授类，实验员类等，只需要new新的子类对象就可以

对象的上下转型

**向上转型 **，多态的写法
类似于 double num=100;int向上转型成double
创建了一只猫，当做动物看待

Animal animal=new Cat();

向下转型
本来是猫转变成动物，把动物进行还原，还原成猫
类似于int num=(int)10.0; (正确写法)
int num=(int)10.5;(错误写法，精度损失)

Animal animal=new Cat();
Cat cat=(Cat)animal;

查看这个父类引用对象本来是父类还是子类
instanceof 类可以得到一个boolean值

public class Test {
public static void main(String[] args) {
// 向上转型
	Animal a = new Cat();
	a.eat(); // 调用的是 Cat 的 eat
// 向下转型，先判断原型
//判断a的原型是不是Cat
	if (a instanceof Cat){
	Cat c = (Cat)a;
	c.catchMouse(); // 调用的是 Cat 的 catchMouse
}
//判断a的原型是不是Dog
else if (a instanceof Dog){
	Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}

笔记本案例分析

• 母口，使用接口，笔记本电脑类，笔记本不管是什么设备统一识别为usb设备
• USB接口，实现交互
• 公口，实现接口，鼠标类、键盘类

接口开关

interface USB {
	void open();// 开启功能
	void close();// 关闭功能
}

笔记本类

class Laptop {
// 笔记本开启运行功能
	public void run() {
	System.out.println("笔记本运行");
}
// 笔记本使用usb设备，这时当笔记本对象调用这个功能时，必须给其传递一个符合USB规则的USB设备
public void useUSB(USB usb) {
// 判断是否有USB设备
	if (usb != null) {
	usb.open();
// 类型转换,调用特有方法，向下转换
if(usb instanceof Mouse){
	Mouse m = （Mouse）usb；
	m.click();
}else if (usb instanceof KeyBoard){
	KeyBoard kb = (KeyBoard)usb;
	kb.type();
}
	usb.close();
}
}
	public void shutDown() {
	System.out.println("笔记本关闭");
}
}

usb设备1，鼠标类

class Mouse implements USB {
@override
public void open() {
	System.out.println("鼠标开启，红灯闪一闪");
}
@override
public void close() {
	System.out.println("鼠标关闭，红灯熄灭");
}
public void click(){
	System.out.println("鼠标单击");
}
}

usb设备1，键盘类

class KeyBoard implements USB {
@override
public void open() {
	System.out.println("键盘开启，绿灯闪一闪");
}
@override
public void close() {
	System.out.println("键盘关闭，绿灯熄灭");
}
public void type(){
	System.out.println("键盘打字");
}
}

测试类

public class Test {
public static void main(String[] args) {
// 创建笔记本实体对象
	Laptop lt = new Laptop();
// 笔记本开启
	lt.run();
// 创建鼠标实体对象
	Usb u = new Mouse();
// 笔记本使用鼠标，传参的时候会进行向上转型
	lt.useUSB(u);
// 创建键盘实体对象
	KeyBoard kb = new KeyBoard();
// 笔记本使用键盘，传参的时候会进行向上转型
	lt.useUSB(kb);
// 笔记本关闭
	lt.shutDown();
}
}