Java小农养成记第九天

舍得..

已于 2022-01-26 16:41:30 修改

阅读量65

点赞数 1

分类专栏： Java学习笔记文章标签： java 开发语言后端

于 2022-01-12 22:00:00 首次发布

本文链接：https://blog.csdn.net/qq_45265623/article/details/122443947

版权

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

46 篇文章 0 订阅

订阅专栏

Day09

第十四章接口

14.1 概述

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

14.2 接口定义及使用

/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字，public，abstract
2.这两个关键字修饰符，可以选择性地省略。
3.方法的三要素，可以随意定义
*/

public interface MyInterfaceAbstract {

    public abstract void methodAbs1();

    abstract void methodAbs2();

    public void methodAbs3();

    void methodAbs4();
}

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{

    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法！");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法！");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法！");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法！");
    }
}

/*
接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

如何定义一个接口的格式：
public interface 接口名称{
    //接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java-->.class。

如果是Java 7，那么接口中可以包含的内容有：
1.常量
2.抽象方法

如果是Java 8，还可以额外包含有：
3.默认方法
4.静态方法

如果是Java 9，还可以额外包含有：
5.私有方法

接口使用步骤：
1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称{
    //....
}

2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体法括号。

3.创建实现类的对象，进行使用。

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
 */
public class Demo01Inferface {
    public static void main(String[] args){
        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }
}

14.3 接口中的常量

/*
接口当中也可以定义“成员变量”，但是必须使用public static final 三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。
格式：
public static final 数据类型 常量名称 = 数据值;

注意：
一旦使用final关键字进行修饰，说明不可改变。

注意事项：
1.接口当中的常量，可以省略public static final，注意：不写也是常量
2.接口当中的常量，必须进行赋值，不能不赋值。
3.接口中常量的名称，使用完全大写得字母，用下划进行分隔。（推荐命名规则）
 */
public interface MyInterfaceConst {

    //这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 10;
}

//调用方法：接口名称.常量名称
public class Demo05Interface {
    public static void main(String[] args) {
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

14.4 Java 8中的默认方法

package cn.itcast.day10.demo01;
/*
从Java 8开始，接口里面允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数列表){
    方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。
 */
public interface MyInterfaceDefault {
    //抽象方法
    public abstract void methodAbs();

    //新添加了一个抽象方法
    //public abstract void methodAbs2();

    //新添加的方法，改成默认方法
    public default void methodAbs2(){
        System.out.println("这是新添加的默认方法");
    }
}

public class MyInterfaceDefaultA implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

public class MyInterfaceDefaultB implements MyInterfaceDefault {
    @Override
    public void methodAbs() {

        System.out.println("实现了抽象方法，BBB");
    }

    @Override
    public void methodAbs2() {
        System.out.println("实现类B重写了接口的默认方法");
    }
}
/*
1.接口的默认方法，可以通过接口实现类对象，直接调用。
2.接口的默认方法，也可以被接口实现类进行覆盖重写。
 */
public class Demo02Interface {
    public static void main(String[] args) {

        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs();
        //调用默认方法，如果实现类中没有，会向上找接口
        a.methodAbs2();//这是新添加的默认方法

        System.out.println("===========================");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodAbs2();//实现类B重写了接口的默认方法
    }
}

14.5 Java 8中的静态方法

/*
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表){
    方法体
}
提升：就是将abstract或者default换成static即可，带上方法体。
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是静态方法");
    }
}

/*
注意事项。不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法:通过接口名称，直接调用其中的静态方法。
格式:
接口名称.静态方法名(参数);

 */
public class Demo03Interface {
    public static void main(String[] args) {
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        //错误写法！
        //impl.methodStatic();

        MyInterfaceStatic.methodStatic();
    }
}

14.6 Java 9中的私有方法

/*
问题描述,
我们需要抽取一个共有方法,用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案:
从Java9开始，接口当中允许定义私有方法。
1.普通私有方法,解决多个就认方法之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表){
    方法体
}

2.静态私有方法，解决多个静态方法之问重复代码问题
格式：
private static 返回值类型 方法名称(参数列表){
    方法体
}
 */
public interface MyInterfacePrivateA {
    public default void methodDefault1(){
        System.out.println("默认方法1");
        method3();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        method3();
    }
    private void method3(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}
public interface MyInterfacePrivateB {
    public static void methodDefault1(){
        System.out.println("默认方法1");
        method3();
    }
    public static void methodDefault2(){
        System.out.println("默认方法2");
        method3();
    }
    private static void method3(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}
public class Demo04Interface {
    public static void main(String[] args) {
        MyInterfacePrivateB.methodDefault1();
        MyInterfacePrivateB.methodDefault2();

    }
}

14.7 接口内容小结

在Java 9+版本中，接口的内容可以有:

[]中的内容可以省略

1．成员变量其实是常量,格式:
[public] [static] [final] 数据类型常量名称 = 数据值;
注意:
常量必须进行赋值,而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。

2．接口中最重要的就是抽象方法,格式:
[public] [abstract]返回值类型方法名称(参数列表);
注意:实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3．从Java 8开始，接口里允许定义默认方法，格式:
[public] default 返回值类型方法名称(参数列表){方法体}
注意:默认方法也可以被覆盖重写

4．从Java 8开始，接口里允许定义静态方法，格式:
[public ] static 返回值类型方法名称(参数列表){方法体}
注意:应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5．从Java9开始，接口里允许定义私有很乏，格式:
普通私有方法: private 返回值类型方法名称(参数列表){ 方法体}
静态私有方法: private static返回值类型方法名称(参数列表){方法体}
注意: private的方法只有接口自己才能调用，不能被实现类或别人使用。

14.8 注意事项

接口是没有静态代码块或者构造方法的。

一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式:

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    //覆盖重写所有抽象方法

}

如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
类与类之间是单继承的。直接父类只有一个。
类与接口之间是多实现的。一个类可以实现多个接口。
接口与接口之间是多继承的。

注意事项:
- 多个父接口当中的抽象方法如果重复，没关系。
- 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

14.9 类和接口的关系

14.9.1 类和接口的区别

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

14.9.2 抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
1. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
1. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
1. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

第十五章多态

15.1 概述

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

15.1.1 多态的优点

1. 消除类型之间的耦合关系
1. 可替换性
1. 可扩充性
1. 接口性
1. 灵活性
1. 简化性

15.1.2 多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

15.2 多态定义

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("这是父类特有方法");
    }
}

public class Zi extends Fu {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

/*
代码当中体现多态性，其实就是一句话:父类引用指向子类对象。
格式:
交类名称 对象名 = new子类名称();
或者:
接口名称 对象名= new 实现类名称();

 */
public class Demo01Polymorphism {
    public static void main(String[] args) {
        //使用多态的写法
        Fu obj = new Zi();
        //创建的对象是谁,就优先用谁,如果没有则向上找
        obj.method();
        obj.methodFu();
    }
}

15.3 多态访问成员变量和成员方法

15.3.1 访问成员变量

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

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

}

/*
访问成员变量的两种方式:
1．直接通过对象名称访问成员变量:
    看等号左边是谁，优先用谁，没有则向上找
2．间接通过成员方法访问：
    该方法属于谁，就优先用谁，没有则向上找。

 */
public class Demo01MultiField {
    public static void main(String[] args) {
        Fu obj = new Zi();
        System.out.println(obj.num);//父类10

        //子类没有覆盖重写，父类10
        //子类如果覆盖重写，子类20
        obj.showNum();
    }
}

15.3.2 访问成员方法

/*
在多态的代码当中，成员方法的访问规则是:
    看new的是谁，就优先用谁,没有则向上找。

口诀:编译看左边，运行看右边。

对比一下:
成员变量:编译看左边，运行还看左边。
成员方法:编译看左边，运行看右边。

 */
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();

        obj.method();//父子都有，优先用子

        obj.methodFu();//子类没有，父类有，向上中安到父类

        //编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
        // obj.methodZi();//错误写法!

    }
}

15.4 对象向上转型和向下转型

15.4.1 对象向上转型

只实就是多态写法:

格式:

父类名称对象名 = new 子类名称();

含义:右侧创建一个子类对象，把它当做父类来看待使用。

注意事项:向上转型一定是安全的。从小范围转向了大范围。


public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

/*
向上转型一定是安全的，没有问题的,正确的。但是也有一个弊端:
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案。用对象的向下转型【还原】
 */
public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
    }
}

15.4.2 对象向下转型

其实是一个【还原】的动作。

格式:

子类名称对象名 = (子类名称) 父类对象;

含义:将父类对象，【还原】成为本来的子类对象。

/*
向上转型一定是安全的，没有问题的,正确的。但是也有一个弊端:
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案。用对象的向下转型【还原】。

注意事项:
a.必须保证对象本来创建的时候。就是猫。才能向下转型成为猫。
b.如果对象创建的时候本来不是描。现在非要向下转型成为猫，就会报错。


 */
public class Demo01Main {
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Cat();
        animal.eat();

        //animal.catchMouse();错误写法

        //向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠

        //错误向下转型
        //本来new的时候是一只猫，现在非要当做狗
        //错误写法，编译不会报错，但是运行会出现异常
        //java.lang.ClassCastException,类转换异常
        //Dog dog = (Dog) animal;
    }
}

15.5 用instanceof关键字进行类型判断

/*
如何才知道一个父类引用的对象，本来是什么子类？
格式:
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

 */
public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat();//本来是一只猫

        animal.eat();//猫吃鱼

        //如果希望调用子类特有方法，需要向下转型
        //判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        //判断一下animal本来是不是Cat
        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
        giveMeAPet(new Dog());
    }
    public static void giveMeAPet(Animal animal){
        //判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        //判断一下animal本来是不是Cat
        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

15.6 接口多态的综合案例

15.6.1笔记本电脑

笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。

定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

15.6.2 案例分析

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘.

USB接口，包含打开设备功能、关闭设备功能
笔记本类，包含开机功能、关机功能、使用USB设备功能
鼠标类，要实现USB接口，并具备点击的方法
键盘类，要实现USB接口，具备敲击的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-slUWS4wg-1641914327703)(index_files/61a63fad-34d7-4b33-aae8-f44bcbe0c580.png)]

public interface USB {
    public abstract void open();
    public abstract void close();
}

//键盘就是一个USB设备
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("键盘输入");
    }
}


//鼠标就是一个USB设备
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 class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    //使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb){
        usb.open();//打开设备
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.click();
        }else if (usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard) usb;
            keyboard.type();
        }
        usb.close();//关闭设备
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        //创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        //准备一个鼠标，供电脑使用
        //Mouse mouse = new Mouse();
        //首先进行向上转型
        USB usbMouse = new Mouse();
        computer.useDevice(usbMouse);

        //创建一个USB键盘
        Keyboard keyboard = new Keyboard();//没有使用多态方法

        //方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard);//正确写法。发生了向上转型了
        computer.useDevice(new Keyboard());//正确写法。发生了向上转型了

        computer.powerOff();
    }
}