第4节 多态

多态的概述

image.png

多态的格式与使用

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

父类
子类
main方法

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

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

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

在多态的代码当中，成员方法的访问规则是：看new的是谁，就优先用谁，没有则想上找。
口诀：编译看左边，运行看右边。（左边的父类没有子类中的方法，编译就会报错）
对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

使用多态的好处

使用多态的好处

对象的向上转型

向上转型

对象的向下转型

image.png

用instanceof关键字进行

instanceof是Java的一个保留关键字，左边是对象，右边是类，返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。
注意事项：
1、先有继承关系，再有instanceof的使用。
2、当该测试对象创建时右边的声明类型和左边的类其中的任意一个跟测试类必须得是继承树的同一分支或存在继承关系，否则编译器会报错。

public class Application {
  public static void main(String[] args) {
    // Object > Person > teacher
    // Object > Person > Student
    // Object > String
    Object o = new Student(); // 主要看这个对象是什么类型与实例化的类名
    // instanceof关键字可以判断左边对象是否是右边类或者子类的一个实例
    System.out.println(o instanceof Student); // o 是Student类的一个实例对象 所以判断右边类跟student有无关系 以及显示声明有无关系
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    System.out.println(o instanceof String); // false
    System.out.println(o instanceof Teacher); // 无关系
    System.out.println("========================");
    Person person = new Student();
    System.out.println(person instanceof Person); // true
    System.out.println(person instanceof Object); // true
    // System.out.println(person instanceof String); // 编译错误
    System.out.println(person instanceof Teacher); // 无关系
  }
}

应用场景：需要用到对象的强制类型转换时，需要使用instanceof进行判断。

笔记本USB接口案例_分析

笔记本电脑

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

案例分析

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

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

• 键盘类，要实现USB接口,具备敲击的方法

  
  分析

第5节 final关键字

final关键字概念与四种用法

final关键字代表最终、不可改变的。
常见的四种用法

1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

final关键字用于修饰类

当final关键字用来修饰一个类的时候
格式：public final class 类名称 { ... }
含义：当前这个类不能拥有任何子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（因为没儿子）

final关键字用来修饰一个方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，不能被覆盖充重写。
格式：修饰符 final 返回值类型 方法名称(参数列表) { ... }
注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，否则会产生矛盾。

final关键字用于修饰局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能进行修改。一次赋值，终生不变

int num1 = 10;
System.out.println(num1); // 10
num1 = 100;
System.out.println(num1); // 100
// 加上final关键字以后
final int num2;
num2 = 20;
System.out.println(num2); // 20
// num2 = 200; 错误写法 编译会报错

final关键字用于修饰成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不变的。

1. 对于成员变量具有默认性，所以用了final之后必须手动赋值，不会再给默认了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终对final的成员变量进行赋值

权限修饰符

四种权限修饰符

                public > protected > (default) > private
同一个类            YES        YES        YES      YES
同一个包            YES        YES        YES      NO
不同包子类        YES        YES        NO       NO
不同包非子类    YES        NO         NO       NO
注意事项：(default)并不是关键字"default"，而是什么都不写

内部类

内部类的概念与分类

如果一个事物的内部包含另一个事物，那么这就是一个内部类包含另一个类。
例如：身体个心脏的关系，汽车和发动机的关系
分类：

1. 成员内部类
2. 局部内部类（包含匿名内部类）

成员内部类的定义

成员内部类的定义格式：修饰符 class 外部类名称 { 修饰符 class 内部类名称 { ... } ... }
注意：内用外，随意访问；外用内，需要内部类对象。

// 外部类
public class Body {
  // 成员内部类
  public class Heart {
    public void methodHeart() {
      System.out.println("心脏跳动：蹦蹦蹦！");
      System.out.println("姓名：" + name);
    }
  }
  // 外部类的方法
  public void methodBody() {
    System.out.println("外部类的方法");
  }

  // 外部类的成员变量
  private String name;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

成员内部类的使用

如何使用成员内部类？有两种方式：

1. 间接方式：在外部类的方法当中，使用内部类，main方法只是调用外部类的方法
2. 直接方式，公式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

// 外部类
public class Body {
  // 成员内部类
  public class Heart {
    public void methodHeart() {
      System.out.println("心脏跳动：蹦蹦蹦！");
      System.out.println("姓名：" + name);
      new Body().methodBody();
    }
  }
  // 外部类的方法
  public void methodBody() { System.out.println("外部类的方法"); }

  // 外部类的成员变量
  private String name;

  public String getName() { return name; }

  public void setName(String name) { this.name = name; }
}

public static void main(String[] args) {
  Body body = new Body(); // 外部类对象
  // 通过外部类对象，调用外部类方法，里面间接在使用内部类Heart
  body.methodBody();
  System.out.println("===============================");
  // 按照公式写
  Body.Heart heart = new Body().new Heart();
  heart.methodHeart();
}

内部类的同名变量访问

public class Outer {
  int num = 100; // 外部类的成员变量
  public class Inner {
    int num = 200; // 内部类的成员变量
    public void methodInner() {
      int num = 300; // 内部类方法的局部变量
      System.out.println(num); // 局部变量，就近原则
      System.out.println(this.num); // 内部类的成员变量
      System.out.println(Outer.this.num); // 外部类的成员变量
    }
  }
}

public static void main(String[] args) {
  // 公式：外部类名称.内部类名称 变量名 = new 外部类名称().new 内部类名称();
  Outer.Inner inner = new Outer().new Inner();
  inner.methodInner(); // 300 200 100
}

局部内部类定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，除了这个方法就不能使用了。
定义格式：修饰符 class 外部类名称 { 修饰符 返回值类型 外部类方法名称(参数列表) { class 局部内部类名称 { ... } } }

public class Outer1 {
  public void method() {
    class Inner { // 局部类名称
      int num = 10;
      public void methodInner() {
        System.out.println(num);
      }
    }
    new Inner().methodInner();
  }
}

public static void main(String[] args) {
  new Outer1().method(); // 10
}

小结一下类的权限修饰符：public > protected > (default) > private
定义一个类的时候：

1. 外部类：public/(default)
2. 成员内部类：public、protected、(default)、private
3. 局部内部类：什么都不写