day10_接口、多态

2023-11-17 14:46:40

接口

概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类型：数组，类，接口。接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。接口就是类的公共规范

定义格式

public interface 接口名称 {
　　// 接口内容
}

在任何版本的Java中，接口都能定义抽象方法

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

格式：

public abstract 返回值类型方法名称(参数列表);

注意事项：

接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
这两个关键字修饰符，可以选择性地省略。
方法的三要素，可以根据需求随意定义。

举例：

public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}

在任何版本的Java中，接口都能定义常量

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。

格式：

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

注意事项：

接口当中的常量，可以省略public static final，注意：不写也照样是这样。
接口当中的常量，必须进行赋值；不能不赋值。
接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

举例：

public interface MyInterfaceConst {

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

}

接口使用步骤：

1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称 {
　　　　// ...
}
2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。实现：去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用。

注意事项：

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

举例：

定义接口

package demo01;

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

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}

定义实现类

package demo01;

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("这是第四个方法！");
    }
}

定义测试类

package demo01;


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

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

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

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

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

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

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
 */
public class Demo01Interface {

    public static void main(String[] args) {
        //  MyInterfaceAbstract inter = new MyInterfaceAbstract();错误写法！不能直接new接口对象使用。

        // 创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        //使用实现类的抽象方法
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methodAbs2();
        impl.methodAbs4();
        // 访问接口当中的常量
        System.out.println(MyInterfaceAbstract.NUM_OF_MY_CLASS);
    }

}

代码执行后的结果

从Java 8开始，接口里允许定义默认方法

格式：

public default 返回值类型方法名称(参数列表) {
　　　　方法体
}

应用

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

默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

举例：

定义含有默认方法的接口

public interface MyInterfaceDefault {

    // 抽象方法
    public abstract void methodAbs();// 新添加的默认方法
    public default void methodDefault() {
        System.out.println("这是新添加的默认方法");
    }

}

定义实现类继承默认方法

package demo01;

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

定义实现类重写默认方法

package demo01;


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

    @Override
    public void methodDefault() {
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

定义测试类

package demo01;

/*
1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法，也可以被接口实现类进行覆盖重写。
 */
public class Demo02Interface {

    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        // 调用抽象方法，实际运行的是右侧实现类。
        a.methodAbs();
        // 调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault();
        
        System.out.println("=======================");
        
        // 创建了实现类对象
        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault();
    }

}

代码执行后的结果

从Java 8开始，接口当中允许定义静态方法

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

静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用

举例：

定义含有静态方法的接口

public interface MyInterfaceStatic {

    public static void methodStatic() {
        System.out.println("这是接口的静态方法！");
    }

}

定义测试类

package demo01;


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

    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

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

        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }

}

代码执行后的结果

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

1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型方法名称(参数列表) {
　　方法体
}

2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型方法名称(参数列表) {
　　方法体
}

私有方法的使用

私有方法：只有默认方法可以调用。

私有静态方法：默认方法和静态方法可以调用。

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

举例：

package demo01;

public interface MyInterfacePrivateB {
    //静态方法
    public static void methodStatic1() {
        System.out.println("静态方法1");
        //静态私有方法，解决多个静态方法之间重复代码问题
        methodStaticCommon();
    }

    //默认方法
    public default void methodDefault1() {
        System.out.println("默认方法1");
        //普通私有方法，解决多个默认方法之间重复代码问题
        methodCommon();
    }

    //普通私有方法
    private void methodCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

    //静态私有方法
    private static void methodStaticCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

使用接口的时候，需要注意：

1：接口是没有静态代码块或者构造方法的。
2：一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
　　public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
　　　　// 覆盖重写所有抽象方法
　　}
3：如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4：如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5：如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6：一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

小结：

类与类之间是单继承的。直接父类只有一个。
类与接口之间是多实现的。一个类可以实现多个接口。
接口与接口之间是多继承的。
多个父接口当中的抽象方法如果重复，没关系。
多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字。

多态

由来

多态是继封装、继承之后，面向对象的第三大特性。生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义

多态： 是指同一行为，具有多个不同表现形式。

前提

继承或者实现【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

多态的体现

格式：

多态情况下成员变量的访问情况

访问成员变量的两种方式：

直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

访问成员方法

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

简单记

成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

举例：

定义父类

package demo02;


public class Fu /*extends Object*/ {

    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }

}

定义子类

package demo02;


public class Zi extends Fu {

    int num = 20;

    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }

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

    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

定义测试类

package demo02;

public class Test {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); 
        // System.out.println(obj.age); 错误写法！

        //通过成员方法，间接访问成员变量，子类没有覆盖重写，就是父 。子类如果覆盖重写，就是子：

        obj.showNum();
        // 方法父子都有，优先用子
        obj.method();
        // 方法子类没有，父类有，向上找到父类
        obj.methodFu();
        //obj.methodZi(); 错误写法！ 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
    }
}

代码执行后的结果

多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

举例：

定义父类

package demo03;

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

定义子类Cat

package demo03;

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

定义子类Dog

package demo03;

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
}

定义测试类类

package demo03;

public class Test {
    public static void main(String[] args) {
        // 创建对象
        Cat c = new Cat();
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);

        //以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致
        showAnimalEat(c);
        showAnimalEat(d);
    }

    public static void showCatEat(Cat c) {
        c.eat();
    }

    public static void showDogEat(Dog d) {
        d.eat();
    }
    //父类类型作为方法形式参数
    public static void showAnimalEat(Animal a) {
        a.eat();
    }
}

代码执行后的结果

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

多态的弊端

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。怎么解决多态的弊端了，这就不得不提引用类型转换。

引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式

//父类类型 变量名 = new 子类类型(); 
Animal a = new Cat();

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

//子类类型 变量名 = (子类类型) 父类变量名
Cat c =(Cat) a;

转型的异常

向上转型是绝对安全的，比如说把学生当中人类看待是百分之百正确的。向下转型可能会报出了 ClassCastException ，类型转换异常！因为不是百分之百的人类都是学生。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

举例：

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

接口多态的综合案例

笔记本电脑

笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

案例分析

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

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

案例实现

定义USB接口：

package demo04;

public interface USB {

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

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

}

定义鼠标类

package demo04;

// 鼠标就是一个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("鼠标点击");
    }
}

定义键盘类

package demo04;


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

定义笔记本类

package demo04;


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(); // 关闭设备
    }

}

定义测试类

package demo04;


public class DemoMain {

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

        // 准备一个鼠标，供电脑使用
        USB usbMouse = new Mouse(); // 多态写法
        // 参数是USB类型，我正好传递进去的就是USB鼠标
        computer.useDevice(usbMouse);

        // 创建一个USB键盘
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法
        // 方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard); // 正确写法！也发生了向上转型

        // 使用子类对象，匿名对象，也可以computer.useDevice(new Keyboard()); 也是正确写法
        computer.powerOff();

    }
}

代码执行后的结果

码农公寓

接口

概述

定义格式

在任何版本的Java中，接口都能定义抽象方法

在任何版本的Java中，接口都能定义常量

接口使用步骤：

从Java 8开始，接口里允许定义默认方法

从Java 8开始，接口当中允许定义静态方法

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

使用接口的时候，需要注意：

小结：

多态

由来

定义

前提

多态的体现

多态情况下成员变量的访问情况

多态的好处

多态的弊端

引用类型转换

向上转型

向下转型

转型的异常

接口多态的综合案例

笔记本电脑

案例分析

案例实现

相关文章