Java语言入门||02_面向对象与常用类||day10_接口，多态

第一章接口

1.1 接口概述和生活举例

接口就是一种公共的规范标准
- 只要符合规范标准，就可以大家通用

1.2 接口的定义基本格式

接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

定义一个接口的格式：

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

注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java–>.class
接口包含如下：

如果是Java 7，那么接口中可以包含的有：
1. 常量
2. 抽象方法
如果是Java 8，那么接口中额外包含的有：
3. 静态方法
4. 默认方法
如果是Java 9，那么接口中额外包含的有：
5. 私有方法

1.3 接口的抽象方法定义

在任何版本的Java中，接口都能定义抽象方法：（没有方法体）

    //格式：
    public abstract 返回值类型 方法名称（参数列表）;

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

    public interface MyInterfaceAbstract {

        //都是抽象方法
        public abstract void methodAbs();
    
        abstract void methodAbs1();
    
        public void methodAbs2();
    
        void methodAbs3();
    }

1.4 接口的抽象方法使用

接口使用步骤：

接口不能直接使用，必须有一个实现类来实现接口。

    //格式：
    public class 实现类名称 implements 接口名称{
        // ...
    }

接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
- 实现：去掉abstract关键字，加上方法体大括号
创建实现类的对象，进行使用
- 不能直接new接口对象使用
创建名字：接口名+Impl（软性要求）

注意事项：

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

    //定义了一个接口：MyInterfaceAbstract.java
    public interface MyInterfaceAbstract {

        //都是抽象方法
        public abstract void methodAbs();
    
        abstract void methodAbs1();
    
        public void methodAbs2();
    
        void methodAbs3();
    }
    //定义了一个实现类：MyInterfaceAbstractImpl.java
    public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
    
        @Override
        public void methodAbs() {
            System.out.println("这是第一个方法");
        }
    
        @Override
        public void methodAbs1() {
            System.out.println("这是第二个方法");
        }
    
        @Override
        public void methodAbs2() {
            System.out.println("这是第三个方法");
        }
    
        @Override
        public void methodAbs3() {
            System.out.println("这是第四个方法");
        }
    }
    //主方法：Demo01Interface.java
    public static void main(String[] args) {
        //错
        //MyInterfaceAbstract inter = new MyInterfaceAbstract();

        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs();
        impl.methodAbs1();
    }

1.5 接口的默认方法定义(Java 8)

从Java 8开始，接口里允许定义默认方法:（有方法体）

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

注：接口当中的默认方法，可以解决接口升级问题(今后课程中：Lambda表达式和函数式编程时候—>接口默认方法可以拼接函数模型)
- 原来接口只有一个抽象方法，拥有很多实现类后
- 这时候接口在添加一个抽象方法，每个实现类都需要覆盖重写
- 实现类不需要覆盖重写，但是还想再接口中添加一个抽象方法
- 所以就要用到默认方法–>带有默认方法体

1.6 接口的默认方法使用

注：public可以省略不写，default不能
注：默认方法会被实现类继承下去
注意事项：
- 接口的默认方法，可以通过接口实现类对象，直接调用
- 接口的默认方法，也可以被接口实现类进行覆盖重写
  - 注：调用抽象方法，实际运行的是右侧的实现类
  - 注：调用默认方法，如果实现类当中没有，会向上找接口

    //定义了一个接口：MyInterfaceDefault.java
    public interface MyInterfaceDefault {

        //抽象方法
        public abstract void methodAbs();
    
        //新添加的抽象方法
        //public abstract void methodAbs2();
        //想新添加方法，改成默认方法
        public default void methodDefault(){
            System.out.println("这是新添加的默认方法");
        }
    }
    //定义了一个实现类a：MyInterfaceDefaultA.java
    public class MyInterfaceDefaultA implements MyInterfaceDefault {
        @Override
        public void methodAbs() {
            System.out.println("实现了抽象方法， AAA");
        }
    }
    //定义了一个实现类b:MyInterfaceDefaultB.java
    public class MyInterfaceDefaultB implements MyInterfaceDefault {
        @Override
        public void methodAbs() {
            System.out.println("实现了抽象方法， BBB");
        }
    
        //覆盖重写了methodDefault
    
        @Override
        public void methodDefault() {
            System.out.println("实现类B覆盖重写了接口的默认方法");
        }
    }
    //主方法：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();  //实现类B覆盖重写了接口的默认方法
    }

1.7 接口的静态方法定义（Java 8）

格式：

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

提示：就是将abstract或者default换成static即可，带上方法体。

1.8 接口的静态方法使用

注：
1. 不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：
1. 格式：
```
    接口名称.静态方法名(参数);
```
1. 静态方法和对象无关，和类有关，所以直接用接口调用方法
  - 直接——>接口名称.方法就行

1.9 接口的私有方法定义和使用（Java 9）

问题描述：
1. 我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题
  - 但是，这个共有的方法不应该让实现类使用，应该是私有化的。
解决方法：
1. 从Java 9 开始，接口当中允许定义私有方法
  1. ++普通私有方法++，解决多个默认方法之间重复代码问题
    - 格式：
```
    private 返回值类型 方法名称(参数){
        方法体
    }
```
  2. ++静态私有方法++，解决多个静态方法之间重复代码问题
    - 格式：
```
    private static 返回值类型 方法名称(参数){
        方法体
    }
```

1.10 接口的常量定义和使用

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

格式：

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

备注：一旦使用final关键字进行修饰，说明不可改变
注：接口当中的常量，可以省略 public static final（不写也照样是这样）
注：接口当中的常量，必须进行赋值，不能不赋值,且赋值完不能改变
注：起接口的常量名时候要大写，多个要用_隔开
- int NUM = 10;
- int NUM_OF_CLASS = 20;

1.11 接口的内容小结

1.12 继承父类并实现多个接口

使用接口时候的注意事项：
1. 接口是没有静态代码块或者构造方法的。
  - static {}
  - public 接口名称() {}
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
```
    public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {    
    
        //覆盖重写所有抽象方法
        
    }
```
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
```
    public abstract class 实现类名 implements 接口名{}
```
5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6. 一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法【重点】
  - 和接口抽象方法重复没事–>因为++没有方法体++

注：Object类是所有类直接或间接的父类(只不过默认省略了)

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

注：写代码的角度来看，接口就是用来规范类的方法【重点】

1.13 接口之间的多继承

类和接口相关的几种关系
1. 类与类之间是单继承的，直接父类只有一个。
2. 类与接口之间是多实现的，一个类可以实现多个接口。
3. 接口与接口之间是多继承的。

注：

多个父接口当中的抽象方法如果重复，没关系。（没有方法体【重点】）
多个父接口当中的默认方法如果重复，有关系了。
- 那么子接口必须进行默认方法的覆盖重写，而且带着default关键字（不能省略）【重点】

   //定义了一个接口：MyInterfaceA.java
   public interface MyInterfaceA {

        public abstract void methodA();
    
        public abstract void common();
    
        public default void methodDefault(){
            System.out.println("AAA");
        }
    }
    //定义了一个接口：MyInterfaceB.java
    public interface MyInterfaceB {

        public abstract void methodB();
    
        public abstract void common();
    
        public default void methodDefault(){
            System.out.println("BBB");
        }
    }
    //定义了一个接口继承上面两个接口：MyInterface.java
    public interface MyInterface extends MyInterfaceA, MyInterfaceB {
    
        public abstract void method();
    
        @Override
        default void methodDefault() {
    
        }
    }
    //定义一个实现类：MyInterfaceImpl
    public class MyInterfaceImpl implements MyInterface {
        @Override
        public void method() {
    
        }
    
        @Override
        public void methodA() {
    
        }
    
        @Override
        public void methodB() {
    
        }
    
        @Override
        public void common() {
    
        }
    }
    //主方法：Demo01Relations.java
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.methodDefault();
    }

第二章多态

2.1 多态的概述

2.2 多态的格式和使用

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

多态：左父右子

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

回顾（访问成员变量的两种方式）：
1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
```
    Fu obj = new Zi();  //父类num=10

    System.out.println(obj.num);    //10：看生成对象的等号左边是谁，优先用谁，没有则向上找
```
1. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找
  - 子类没有覆盖重写，就是父：10
  - 子类覆盖重写，就是子：20

成员变量不能覆盖重写

    定义一个类：Fu.java
    public class Fu {

        int num = 10;
    
        public void showNum(){
            System.out.println(num);
        }
    }
    定义一个子类：Zi.java
    public class Zi extends Fu {

        int num = 20;
    
        int age = 30;   //用于对象左侧是父类，所有调用不到这个
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    }
    主方法：Demo01MultiField.java
    public static void main(String[] args) {

        Fu obj = new Zi();
        System.out.println(obj.num);    //10：看生成对象的等号左边是谁，优先用谁，没有则向上找
        System.out.println("===========");
        obj.showNum();

    }

其中int age = 30; //用于对象左侧是父类，所有调用不到这个

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

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

口诀：编译看左边，运行看右边(看的是创建对象等号两侧)
- 编译（是一个动作）：就是把.java源代码翻译成.class字节码
```
    //obj.methodZi();   //错，编译时候看左边，左边是Fu，Fu当中没有methodZi方法，所以编译错误
```

对比成员变量和成员方法
- 成员变量：编译看左边，运行还看左边
- 成员方法：编译看左边，运行看右边

    //定义一个类：Fu.java
    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("父类特有方法");
        }
    }
    //定义一个子类：Zi.java
    public class Zi extends Fu {

        int num = 20;
    
        int age = 30;   //用于对象左侧是父类，所有调用不到这个
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    }
    主方法：Demo01MultiMethod.java
    public static void main(String[] args) {
        Fu obj = new Zi();

        obj.method();
        obj.methodFu();

        //obj.methodZi();   //错，编译时候看左边，左边是Fu，Fu当中没有methodZi方法，所以编译错误
    }

2.5 使用多态的好处

无论右边new的时候换成那个子类对象，等号左边调用方法都不会变化（更加灵活）

2.6 面向对象的向上转型

对象的向上转型，其实就是多态写法：
- 格式：
- 父类名称对象名 = new 子类名称();//父类引用指向子类对象
- 含义：
- 右侧创建一个子对象，把他当中父类来看待使用
类似于：double num = 100; //对的，int–>double(自动类型转换)

注：向上转型一定是安全的【重点】
注：向上转型是从小范围到大范围

    //定义一个父类：Animal.java
    public abstract class Animal {

        public abstract void eat();
    }
    //定义一个子类：Cat.java
    public class Cat extends Animal {

        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    //主方法：Demo01Main.java
    public static void main(String[] args) {

        //父类引用指向子类对象
        Animal animal = new Cat();

        animal.eat();
    }

2.7 面向对象的向下转型

向上转型的弊端：
- 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
解决方案：
- 用对象的向下转型【还原】

格式：

子类名称对象名 = （子类名称）父类对象名;

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

含义：
- 将父类对象，【还原】成为本来的子类对象。（类似于：强制类型转换–>int num = (int)10.0;可以， int num = (int)10.5;不可以，精度损失）
注意事项：
1. 必须保证对象本来创建的时候，就是猫，才能向下转型为猫
2. 如果对象创建的时候本来不是猫，现在非要向下转型为猫
  - 不报错，但是会运行异常
  - java.lang.ClassCastException：类转换异常

    //定义一个父类：Animal.java
    public abstract class Animal {

        public abstract void eat();
    }
    //定义一个子类：Cat.java
    public class Cat extends Animal {

        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        public void catchMouse(){
            System.out.println("猫抓老鼠");
        }
    }
    //定义另一个子类：Dog.java
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃屎");
        }
    
        public void watchHouse(){
            System.out.println("狗看家");
        }
    }
    //主方法：Demo01Main.java
    public static void main(String[] args) {

        //父类引用指向子类对象
        Animal animal = new Cat();

        animal.eat();

        //animal.catchMouse();  //错，父类没有该方法

        //向下转型
        Cat cat = (Cat)animal;

        cat.catchMouse();

        //向下错误转型，因为new的是一只猫
        //Dog dog = (Dog)animal;  //错误写法，不报错，但是会运行异常

        //dog.watchHouse();

        int num = (int)10.5;    //不行，精度损失
        System.out.println(num);
    }

2.8 用instanceof关键字进行类型转换

如何才能知道一个父类的引用的对象，本来是什么子类
格式：
- 对象 instanceof 类名称
- 这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类名称的实例
向下转型时候怕转错了一定要用instanceof来进行判断

    //定义一个父类：Animal.java
    public abstract class Animal {

        public abstract void eat();
    }
    //定义一个子类：Cat.java
    public class Cat extends Animal {

        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        public void catchMouse(){
            System.out.println("猫抓老鼠");
        }
    }
    //定义一个子类：Dog.java
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃屎");
        }
    
        public void watchHouse(){
            System.out.println("狗看家");
        }
    }
    //主方法：Demo02Instanceof
    public class Demo02Instanceof {
        public static void main(String[] args) {
    
            Animal animal = new Cat();
    
            animal.eat();
    
            giveMeAnAnimal(new Dog());
        }
    
        public static void giveMeAnAnimal(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();
            }
        }
    }

结果：
- 猫吃鱼
- 狗看家

2.9 笔记本USB接口案例_分析

2.9 笔记本USB接口案例_实现

    //定义一个接口USB.java
    public interface USB {

        //因为不知道打开的是什么设备所以用abstract
        public abstract void open();    //打开设备
        public abstract void close();   //关闭设备
    }
    
    
    //定义一个笔记本类：Computer.java
    public class Computer {

        public void powerOn(){
            System.out.println("笔记本电脑开机");
        }
    
        public void powerOff(){
            System.out.println("笔记本电脑关机");
        }
    
        //使用USB设备的方法，使用接口作为方法的参数
        public void userDevice(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();    //关闭设备
        }
    }
    
    
    //定义一个鼠标实现类：Mouse.java
    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("鼠标点击");
        }
    }
    
    
    //定义一个键盘实现类：Keyboard.java
    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("键盘输入");
        }
    }
    
    
    //主方法：DemoMain.java
    public static void main(String[] args) {

        Computer computer = new Computer();

        computer.powerOn();

        //准备一个鼠标供电脑使用(首先向上转型)
         USB usbMouse = new Mouse();    //多态写法（第一种）
         computer.userDevice(usbMouse);

         //准备一个键盘
        Keyboard usbKeyboard = new Keyboard();   //没有使用多态（第二种）
        //参数是一个USB类型，传递进去的是实现类对象
        computer.userDevice(usbKeyboard);   //也发生了向上转型
        //使用子类对象，匿名对象，也可以（第三种）
        //computer.userDevice(new Keyboard());    //也可以

        computer.powerOff();
    }

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1140

私信关注

Java语言入门||02_面向对象与常用类||day10_接口，多态

第一章 接口

1.1 接口概述和生活举例

1.2 接口的定义基本格式

1.3 接口的抽象方法定义

1.4 接口的抽象方法使用

1.5 接口的默认方法定义(Java 8)

1.6 接口的默认方法使用

1.7 接口的静态方法定义（Java 8）

1.8 接口的静态方法使用

1.9 接口的私有方法定义和使用（Java 9）

1.10 接口的常量定义和使用

1.11 接口的内容小结

1.12 继承父类并实现多个接口

1.13 接口之间的多继承

第二章 多态

2.1 多态的概述

2.2 多态的格式和使用

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

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

2.5 使用多态的好处

2.6 面向对象的向上转型

2.7 面向对象的向下转型

2.8 用instanceof关键字进行类型转换

2.9 笔记本USB接口案例_分析

2.9 笔记本USB接口案例_实现

猜你喜欢

第一章接口

第二章多态