发表文章

[最新] day10【接口、多态】

qq36172874 3月前 1

day10【接口、多态】

接口概述与生活举例

01-接口的生活举例这里写图片描述

接口的定义基本格式

程序当中定义一个接口的格式:
public interface 接口名称 {
// 接口的内容
}

虽然使用了interface关键字,但是编译之后产生的字节码文件仍然是.class文件。

接口的抽象方法定义

目前我们使用的JDK版本是9.0,所以接口当中总共可以包含的内容有五个部分:

  1. 抽象方法
  2. 默认方法
  3. 静态方法
  4. 私有方法
  5. 常量

接口的抽象方法使用

如何使用接口当中的抽象方法:

  1. 不能直接new接口
  2. 必须有一个实现类,去实现接口
    public class 实现类名称 implements 接口名称 {
    // …
    }
  3. 实现类当中必须覆盖重写所有的抽象方法。
  4. 创建实现类对象进行使用。

接口的默认方法定义

从Java 8开始,接口里面可以定义默认方法:
public default 返回值类型 方法名称(参数列表) {
方法体
}

备注:
1. public关键字可以省略,就算不写,也照样是public的。但是default关键字不能省略。
2. 这是Java 8特性之一。
3. 接口当中的默认方法一般不强制要求覆盖重写。
4. 然而实现类也是可以对默认方法进行覆盖重写的。

接口的默认方法使用

接口的静态方法定义

Java 8还允许接口当中定义静态方法:
如果一个方法和对象无关,那么就可以定义成为静态方法。

格式:
public static 返回值类型 方法名称(参数列表) {
方法体
}

备注:
public可以省略,就算不写public,也照样是public。但是static不能省略。

注意:
接口当中的静态方法使用,不能通过实现类对象调用。

接口的静态方法使用

使用格式:
接口名称.静态方法名(参数);

接口的私有方法定义

从Java 9开始,接口当中允许定义私有方法:

public interface 接口名称 {
// 普通的私有方法
private 返回值类型 方法名称(参数列表) {
方法体
}

// 静态的私有方法
private static 返回值类型 方法名称(参数列表) {
    方法体
}

}

注意事项:
1. 这个特性是Java 9才有的。
2. 静态不能直接调用非静态,
private用来解决default方法之间的重复代码
private static用来解决static方法之间的重复代码
3. 任何一个关键字都不能省略。

接口的私有方法使用

接口的常量定义和使用

接口当中还可以包含常量。
public static final 数据类型 常量名称 = 数据值;

注意事项:
1. public static final三个关键字都可以省略,也可以省略其中的任意多个。
2. final关键字代表“最终”,也就是不可改变的意思。
3. 接口当中的常量,必须进行赋值,不能不赋值。
4. 接口当中的常量,命名规则为:所有字母一律大写,中间使用下划线分隔。
5. 使用接口中常量的格式:
接口名称.常量名

小结接口成员的特点

小结一下接口当中的组成部分:

定义接口的基本格式(外层的框架)

public interface 接口名称 {
1. 常量
2. 抽象方法
3. 默认方法 // Java 8
4. 静态方法 // Java 8
5. 私有方法 // Java 9
}

常量
public static final 数据类型 常量名称 = 数据值;

抽象方法
public abstract 返回值类型 方法名称(参数列表); // 没有大括号

默认方法
public default 返回值类型 方法名称(参数列表) {} // 有大括号

静态方法
public static 返回值类型 方法名称(参数列表) {} // 有大括号

私有方法
private 返回值类型 方法名称(参数列表) {} // 有大括号
private static 返回值类型 方法名称(参数列表) {} // 有大括号

继承父类并实现多个接口

一个类在继承父类的同时,实现多个接口的格式:
public class 类名称 extends 父类 implements 接口A, 接口B {
// …
}

  1. 这个类必须覆盖重写所有的抽象方法。
  2. 如果父类和/或多个接口之间存在重复的抽象方法,那么只要覆盖重写一次即可。
  3. 如果这个类没有做到覆盖重写所有抽象方法,那么这个类自己也必须是一个抽象类。
  4. 对于多个接口当中存在冲突的默认方法,实现类必须进行覆盖重写。
  5. 父类的方法,优先于接口当中的默认方法

接口之间的多继承

  1. 类与类之间与单继承关系。
  2. 类与接口之间是实现关系。
  3. 接口与接口之间是多继承关系。

public interface 接口名 extends 父接口A, 父接口B {
// …
}

子接口的实现类,必须覆盖重写来自于所有接口的所有抽象方法。
如果多个父接口当中存在重复的抽象方法,无所谓。
如果多个父接口当中存在冲突的默认方法,那么子接口必须覆盖重写默认方法,而且带着default关键字。

多态的概述

02-多态性的概述这里写图片描述

多态的格式和使用

多态性在代码当中的体现就是:左父右子,或者左接口右实现。

在继承关系当中使用多态:
父类 对象名 = new 子类();

在实现关系当中使用多态:
接口 对象名 = new 实现类();

使用多态的时候,【重要】特点是:
编译看左边,运行看右边。
“由左边决定能不能调用;由右边决定运行的是谁。”

多态中成员变量的使用特点

多态当中成员变量的访问特点:
直接通过对象名称访问成员变量:
等号左边是谁,优先用谁;如果没有,向上找父类。
间接通过成员方法访问成员变量:
该方法属于谁,优先用谁;如果没有,向上找父类。

多态中成员方法的使用特点

多态当中成员方法的访问特点:
看new的是谁,优先用谁;如果没有,向上找父类。

使用多态的好处

03-使用多态的好处
这里写图片描述

对象的向上转型

向上转型:将本来一个子类对象,向上转换成为父类类型。

向上转型的格式:
父类 对象名 = new 子类();
或者:
接口 对象名 = new 实现类();
注意:对象向上转型之后,就不能再调用子类特有的方法了。

对象的向下转型

向下转型:将一个父类对象,向下转换成为子类类型。

向下转型的格式:
子类 对象名 = (子类) 父类对象
或者:
实现类 对象名 = (实现类) 接口对象

对象的上下转型图解04-对象的上下转型这里写图片描述

用instanceof关键字进行类型判断

通过关键字【instanceof】可以判断一个对象是不是指定类型的实例:
对象 instanceof 类名称
这将会得到一个boolean值,如果是true代表可以转换成为后者类型;如果是false就代表不可以转换成为后者类型

注意:
一定要保证向下转型之前,首先通过instanceof判断。绝对不能直接想当然地向下转型。

笔记本USB接口案例_分析

06-笔记本案例中的向上转型这里写图片描述这里写图片描述

笔记本USB接口案例_实现

public class Computer {

public void powerOn() {
    System.out.println("开机");
}

public void powerOff() {
    System.out.println("关机");
}

// 使用设备
public void useDevice(USB usb) {
    usb.open();

    if (usb instanceof Mouse) {
        Mouse mouse = (Mouse) usb;
        mouse.click();
    }
    if (usb instanceof Keyboard) {
        Keyboard key = (Keyboard) usb;
        key.type();
    }

    usb.close();
}

}

public class Keyboard implements USB {
@Override
public void open() {
System.out.println(“打开键盘”);
}

@Override
public void close() {
    System.out.println("关闭键盘");
}

public void type() {
    System.out.println("键盘打字!PiaPiaPia!");
}

}

public class Mouse implements USB {
@Override
public void open() {
System.out.println(“打开鼠标”);
}

@Override
public void close() {
    System.out.println("关闭鼠标");
}

public void click() {
    System.out.println("鼠标点击!哒哒哒!");
}

}

public interface USB {

public abstract void open(); // 打开设备

public abstract void close(); // 关闭设备

}

public class DemoMain {

public static void main(String[] args) {
    Computer computer = new Computer();
    computer.powerOn();

    USB mouse = new Mouse(); // 向上转型
    computer.useDevice(mouse);

    Keyboard key = new Keyboard(); // 没有多态,这一行没有向上转型
    computer.useDevice(key); // 照样正确!照样也是向上转型

    computer.powerOff();

    method(5);
}

public static void method(double num) {
    System.out.println(num);
}

}

总结

定义接口的基本格式(外层的框架)

public interface 接口名称 {
1. 常量
2. 抽象方法
3. 默认方法 // Java 8
4. 静态方法 // Java 8
5. 私有方法 // Java 9
}

常量
public static final 数据类型 常量名称 = 数据值;

抽象方法
public abstract 返回值类型 方法名称(参数列表); // 没有大括号

默认方法
public default 返回值类型 方法名称(参数列表) {} // 有大括号

静态方法
public static 返回值类型 方法名称(参数列表) {} // 有大括号

私有方法
private 返回值类型 方法名称(参数列表) {} // 有大括号
private static 返回值类型 方法名称(参数列表) {} // 有大括号

实现接口的格式:
public class 类名称 implements 接口名称 {
// 覆盖重写所有抽象方法
}

使用多态的前提是继承,继承可以体现在两个方面:
1. 要么有类与类之间的继承关系
2. 要么有类与接口之间的实现关系

向上转型:将子类对象向上转换成为父类对象。
格式:父类 对象名 = new 子类();
代码:Animal animal = new Cat();

向下转型:将父类对象向下转换成为子类对象。
格式:子类 对象名 = (子类) 父类对象;
代码:Cat cat = (Cat) animal;
注意:一定要先使用instanceof关键字进行判断,然后判断成功才能转换。

关键字instanceof如何使用:
格式:对象 instanceof 类
含义:判断一下前面的对象能不能转换成为后面的类型。

相关推荐
最新评论 (0)
返回
发表文章
qq36172874
文章数
12
评论数
0
注册排名
1352015