1. 多态

  • 调用成员变量时：编译看左边，运行看左边

  • 调用成员方法时：编译看左边，运行看右边

1.1 多态的形式

image-20220729090707045

多态是继封装、继承之后，面向对象的第三大特性。

多态是出现在继承或者实现关系中的。

多态体现的格式： 

1
2
父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();

多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

1.2 多态的使用场景

在这种情况下，只能定义不同的register方法分别接收学生，老师和管理员等。但是每个都写一个register方法，太麻烦，太琐碎了。都是重复的代码。（就是面向过程了）

image-20220729090201250

但现在有了多态之后，方法的形参就可以定义为共同的父类Person。老师类学生类都可以继承这个Person类。

image-20220729090606815

要注意的是：

  • 当一个方法的形参是一个类，我们可以传递这个类所有的子类对象。
  • 当一个方法的形参是一个接口，我们可以传递这个接口所有的实现类对象（后面会学）。
  • 而且多态还可以根据传递的不同对象来调用不同类中的方法。

1.3 多态的定义和前提

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

前提【重点】

  1. 有继承或者实现关系

  2. 方法的重写【意义体现：不重写，无意义】

  3. 父类引用指向子类对象【格式体现】

    父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

1.4 多态的运行特点

  • 调用成员变量时：编译看左边，运行看左边

  • 调用成员方法时：编译看左边，运行看右边

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Fu f = new Zi()；
//编译看左边的父类中有没有name这个属性，没有就报错
//在实际运行的时候，把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是子类中的show方法
f.show();

//理解：
        //Fu f = new Zi()；
        //现在用f去调用变量和方法的呀？是的
        //而f是Fu类型的，所以默认都会从Fu这个类中去找

//成员变量：在子类的对象中，会把父类的成员变量也继承下的。父：name  子：name
//成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。

1.5 多态的优势和弊端

  • 优势：

方法中，使用父类型作为参数，可以接收所有子类对象。（重要）

  • 劣势：

我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Animal{
    public  void eat()｛
        System.out.println("动物吃东西！")
    ｝
}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
   
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

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

class Test{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
    }
}

image-20220729160014599

说明：正常情况下，父类是不能用子类的方法的，但是如果想用可以，强制类型转换，转换成真正的子类类型。这样可以调用子类的独有功能。

1.6 引用类型转换

1.6.1 为什么要转型

多态的写法就无法访问子类独有功能了。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点”小麻烦”。所以，想要调用子类特有的方法，必须做向下转型。

回顾基本数据类型转换

  • 自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
  • 强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14

​ 多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。

1.6.2 向上转型（自动转换）

  • 向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
    当父类引用指向一个子类对象时，便是向上转型。
    使用格式：
1
2
父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。所以子类范围小可以直接自动转型给父类类型的变量。

1.6.3 向下转型（强制转换）

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

使用格式：

1
2
3
子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
   Cat c =(Cat) a;

1.6.4转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

1
2
3
4
5
6
7
8
9
10
11
public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。

1.6.5 instanceof关键字

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

1
2
3
变量名 instanceof 数据类型 
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

1.6.6 instanceof新特性

JDK14的时候提出了新特性，把判断和强转合并成了一行

1
2
3
4
5
6
7
8
9
10
//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
    d.lookHome();
}else if(a instanceof Cat c){
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}

2.包

2.1 包

image-20220729093659517

包名的命名规范：

1
2
路径名.路径名.xxx.xxx
// 例如：com.itheima.oa

2.2 使用不同包下的相同类怎么办？

假设demo1和demo2中都有一个Student该如何使用？

代码示例：

1
2
3
4
5
//使用全类名的形式即可。
//全类名：包名 + 类名
//拷贝全类名的快捷键：选中类名crtl + shift + alt + c 或者用鼠标点copy，再点击copy Reference
com.itheima.homework.demo1.Student s1 = new com.itheima.homework.demo1.Student();
com.itheima.homework.demo2.Student s2 = new com.itheima.homework.demo2.Student();

3.权限修饰符

3.1 权限修饰符

​ 在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，我们之前已经学习过了public 和 private，接下来我们研究一下protected和默认修饰符的作用。

  • public：公共的，所有地方都可以访问。

  • protected：本类 ，本包，其他包中的子类都可以访问。

  • 默认（没有修饰符）：本类 ，本包可以访问。

    注意：默认是空着不写，不是default

  • private：私有的，当前类可以访问。
    public > protected > 默认 > private

3.2 不同权限的访问能力

public protected 默认 private
同一类中 √ √ √ √
同一包中的类 √ √ √
不同包的子类 √ √
不同包中的无关类 √

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

  • 成员变量使用private ，隐藏细节。
  • 构造方法使用 public ，方便创建对象。
  • 成员方法使用public ，方便调用方法。

小贴士：不加权限修饰符，就是默认权限

# 4.final关键字

4.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。如果有一个方法我不想别人去改写里面内容，该怎么办呢？

final： 不可改变，最终的含义。可以用于修饰类、方法和变量。

  • 类：被修饰的类，不能被继承。（API）
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，有且仅能被赋值一次。（比如圆周率3.14）

我们一般用来修饰变量最多的，大佬才来定义类和方法。

4.2.1 修饰类

final修饰的类，不能被继承。

格式如下：

1
2
final class 类名 {
}

代码:

1
2
3
final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

4.2.2 修饰方法

final修饰的方法，不能被重写。
格式如下：

1
2
3
修饰符 final 返回值类型 方法名(参数列表){
    //方法体
}

4.2.3 修饰变量-局部变量

  1. 局部变量——基本类型
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
1
2
3
4
for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

4.2.4 修饰变量-成员变量

成员变量涉及到初始化的问题，初始化方式有显示初始化和构造方法初始化，只能选择其中一个：

  • 显示初始化(在定义成员变量的时候立马赋值)（常用）；
1
2
3
public class Student {
    final int num = 10;
}

  • 构造方法初始化(在构造方法中赋值一次)（不常用，了解即可）。

    注意：每个构造方法中都要赋值一次！

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class Student {
        final int num = 10;
        final int num2;

        public Student() {
            this.num2 = 20;

    //     this.num2 = 20;
        }
        

         public Student(String name) {
            this.num2 = 20;

    //     this.num2 = 20;
        }
    }

被final修饰的常量名称，一般都有书写规范，所有字母都大写。