《JavaSE-第九章》之继承与多态-CSDN博客

本文链接：https://blog.csdn.net/qq_60308100/article/details/124851162

本文详细讲解了Java中的继承与多态。继承是子类从父类继承属性和行为，实现代码复用，多态则允许子类对象在调用同一方法时表现出不同行为。文中通过实例代码展示了继承的语法、注意事项、父类成员的访问、子类构造方法、super关键字的使用，以及多态的实现条件和特点。此外，还探讨了访问权限修饰符、final关键字的用法，以及单继承、多层继承和支持多层继承的特性。文章最后讨论了组合与继承的差异，以及向上转型和向下转型的概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

本章重点介绍面向对象的三大特征的继承与多态。现实中某一人类继承了继承了其父母亲的基因，也继承了家产。对应在Jvaa世界中则是如果两个类之间的关系是is-a的关系则构成继承，比如狗是一只动物，狗就继承了动物的属性与行为。自然界中有万千生物，每一种生物都能“走”,都能发出“声音”,但是走的姿势与声音是截然不同的，这就是多态。

博客主页：KC老衲爱尼姑的博客主页

博主的github，平常所写代码皆在于此

共勉：talk is cheap, show me the code

作者是爪哇岛的新手，水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

文章目录

@[toc]

🚀1.什么是继承?
🚀1.1为什么要有继承？
🚀1.2继承的语法
🚀1.3注意事项
🚀1.4父类成员的访问
🚀1.5子类中访问父类的成员方法
🚀1.6子类方法中访问成员总结

🚀1.7super关键字
🚀1.8子类构造方法
🚀1.9父类中有参构造器
🚀2.0父类中即有无参也有带参的构造器
🚀2.1super总结

🚀2.2再谈初始化

🚀2.3protected关键字
🚀2.4访问权限修饰符的使用
🚀2.5继承特点
🚀2.6单继承
🚀2.7支持多层继承
🚀2.8继承有哪些特点？

🚀2.9final关键字
🚀3.0继承与组合

🚀4.0多态
🚀4.1多态的实现条件

🚀4.2多态中成员访问特点
🚀4.3重写和重载的区别
🚀4.3.1静态绑定
🚀4.3.2动态绑定

🚀4.4向上转移和向下转型
🚀4.4.1向上转型
🚀4.4.2向下转型

🚀4.5多态的优缺点
🚀4.5.1优势
🚀4.5.2劣势

🚀1.什么是继承?

定义：继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。

大白话就是张三作为一个人，自然拥有一个人最基本的属性，比如吃喝拉撒呼吸空气，这些都是一个人从其父母亲哪里继承过来的。

🚀1.1为什么要有继承？

回答这个问题之前先来看三个类

Student类

public class Student {
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
    public void study(){
        System.out.println("正在学习编程");
    }
}

Teacher类

public class Teacher {
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
    public void teach(){
        System.out.println("正在教书");
    }
}

Worker类

public class Worker {
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
    public void work(){
        System.out.println("正在打螺丝");
    }
}

我们可以发现学生，老师，工人都具备相同的属性以及部分相同的方法，这也许还没有什么毕竟只是几行代码，我们稍加思考如果我们要在java中创建一个学校中的所有人那么我们要写多少行重复的代码，那么是否有一种方法能解决代码重复的问题呢?在java中是使用类对现实世界中的实体进行描述，而现实中的实体有着错综复杂的关系，不单单是单独造几个类就能描述的，我们需要在现有类基础上进一步抽象出他们的共性，将这些共性单独封装成一个类，然后让学生老师工人使用即可，这样就可以提高代码的复用性，同时我们只需在这个进一步抽象的类中添加属性和行为，那么使用它的类自然也被拥有。比如我们刚看到的这三个类，我们可以提取出重复的代码，对这三者进一步抽象(找相同)可以得知他们都是人类，所以可以将提取出来的代码封装进人类。人类又是如何被三者使用的呢?我们自己就是人类，因为我们继承了人的基因，所以拥有了人的属性，同理我们只需让学生，工人，老师继承人类即可。

Person类

public class Person {
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
}

由此可知继承的作用是对共性的抽取，实现代码复用。

🚀1.2继承的语法

在java中表明类与类之间的关系是继承关系，需要使用extends关键字来标识，格式如下

修饰符 class 子类 extends 父类 {
// ... 
}

在java中子类也被称之为派生类，父类被称为超类或基类。了解了java中的继承使用后，对上述代码进行重新设计。
Student类

public class Student extends Person{
    public void study(){
        System.out.println("正在学习编程");
    }
}

Worker类

public class Worker extends Person{
    public void work(){
        System.out.println("正在打螺丝");
    }
}

Teache类

public class Teacher extends Person{
    public void teach(){
        System.out.println("正在教书");
    }
}

Text类

public class Text {
    public static void main(String[] args) {
        Student s=new Student();
        Teacher t=new Teacher();
        Worker w=new Worker();
        s.study();
        System.out.println(s.name = "老衲爱尼姑");
        System.out.println(s.age = 19);
        t.teach();
        System.out.println(t.name = "老衲");
        System.out.println(t.age = 90);
        System.out.println(w.age = 89);
        System.out.println(w.name = "老衲不爱尼姑");
        w.work();
    }
}
//运行结果
//正在学习编程
//老衲爱尼姑
//19
//正在教书
//老衲
//90
//89
//老衲不爱尼姑
//正在打螺丝

🚀1.3注意事项

子类会将父类的成员变量或者成员方法继承。
子类继承父类后，必须拥有自己独特的成有，特现出于基类的不同，否则就没必要继承。

子承父业，学生类，老师类以及工人类它们在堆内存上的信息不仅仅是我们在子类代码中看到的成员，既然是继承它也包含了从父类继承过来的成员，如下图所示

在这里插入图片描述

子类的成员既有自己独特的也有父类的，总得来说都是子类的。

🚀1.4父类成员的访问

在继承体系中，子类继承了父类的成员，那么我们将如何去访问父类中的成员呢?答案是通过super关键字。

子类中访问父类成员变量

1.子类和父类不存在同名的成员变量

上代码

public class Person {
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
}


public class Student extends Person{
    public String address;
    public void study(){
        System.out.println("正在学习编程");
    }
    public void method(){
        address="中国";
        age=90;
        name="老衲爱尼姑";
    }
}

子类和父类不存在同名的成员变量时直接访问就行了。

2.子类和父类成员变量同名

public class Person {
    public int a=12;
    public int b=34;
    public int c=45;
}
public class Student extends Person{
    public String address;
    public int a=90;
    public int b=89;
    public void method(){
        System.out.println(a);//子类的
        System.out.println(b);//子类的
        System.out.println(c);//父类的
    }

    public static void main(String[] args) {
        Student s=new Student();
        s.method();
    }
}
//运行结果
//90
//89
//45

而我们就子类和父类中的成员都就地初始化，在打印出来，便可以知道是先访问父类还是子类的成员了。

在子类方法中或者通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

🚀1.5子类中访问父类的成员方法

成员方法名字不同

代码示例

public class Person {
    public int a=12;
    public int b=34;
    public int c=45;
    public void method2(){
        System.out.println("person的方法");
    }
}

public class Student extends Person{
    public String address;
    public int a=90;
    public int b=89;
    public void method1(){
        System.out.println("Student的方法");
    }

    public void method3(){
        System.out.println("Student的方法");
        method2();
    }

    public static void main(String[] args) {
        Student s=new Student();
        s.method3();
    }
}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

成员方法名字相同

public class Person {
    public int a=12;
    public int b=34;
    public int c=45;
    public void methodA(){
        System.out.println("person的方法A");
    }
    public void methodB(){
        System.out.println("person的方法B");
    }
}

public class Student extends Person{
    public String address;
    public int a=90;
    public int b=89;
    public void methodA(int a){
        System.out.println("Student的方法A");
    }
    public void methodB(){
        System.out.println("Student的方法B");
    }
    public void methodC(){
       methodA(12);
       methodA();
       methodB();
       super.methodB();
    }
    public static void main(String[] args) {
        Student s=new Student();
        s.methodC();
    }

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

🚀1.6子类方法中访问成员总结

在子类方法中访问成员(成员变量,成员方法)满足：就近原则

先子类局部范围找
然后子类成员范围找
然后父类成员范围找，如果父类范围还没有找到则报错。

🚀1.7super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

代码示例

public class Person {
    public int a=12;
    public int b=34;
    public int c=45;
    public void methodA(){
        System.out.println("person的方法A");
    }
    public void methodB(){
        System.out.println("person的方法B");
    }
}

public class Student extends Person {
    public int a = 90;
    public int b = 89;

    public void methodA(int a) {
        System.out.println("Student的方法A");
    }

    public void methodB() {
        System.out.println("Student的方法B");
    }

    public void methodC(Student this) {
        this.methodA(12);
        this.methodB();
        super.methodA();
        super.methodB();
        System.out.println(this.a);
        System.out.println(this.b);
        System.out.println(super.a);
        System.out.println(super.b);
        System.out.println(super.c);

    }

    public static void main(String[] args) {
        Student s = new Student();
        s.methodC();
    }
}

使用this访问当前类的成员，使用super在非静态方法中访问父类成员，如果想要明确访问父类中成员时，借助super关键字即可。

【注意事项】

只能在非静态方法中使用

解释：this是指向当前对象的引用，super是子类从父类继承过来的那部分成员的引用。这些对象引用存放在栈区，而static修饰的方法在方法区。所以方法区中压根没有对象的引用，自然就不能访问。

🚀1.8子类构造方法

子类会继承父类的成员，那么父类的成员变量是先初始化于子类成员变量之前的。即当子类构造时，先调用父类的构造方法，然后执行子类的构造方法。

代码示例

public class Person {
    public Person(){
        System.out.println("person的构造方法");
    }

}
public class Student extends Person{
    public  Student (){
        super();//在子类构造方法中默认会调用父类的构造方法即：super();用户没有添加则自动调加，并且在子类构造方法的第一行，且只出现一次。
        System.out.println("Student的构造方法");
    }

    public static void main(String[] args) {
        new Student();
    }
}
//运行结果
//person的构造方法
//Student的构造方法

this与super不能同时出现在子类构造方法的第一行

public class Student extends Person{
    public  Student (){
        super();
        this(12,12);
        System.out.println("Student的构造方法");
    }
    public  Student (int a,int b){
        System.out.println("Student的构造方法"+a+b);
    }

    public static void main(String[] args) {
        new Student();
    }
}

对于上述代码是无法编译通过的，因为this和super都想默认在子类构造器中的第一行，而第一只有一个，两者便会发生冲突，导致无法编译。

🚀1.9父类中有参构造器

代码示例

public class Person {
    public String name;
    public int age;
//    public Person(){
//        System.out.println("person的构造方法");
//    }
    public Person(String name,int age){
        System.out.println("person的有参构造方法"+name+age);
    }
}

public class Student extends Person{
    public  Student (){
        super("老衲爱尼姑",12);
        System.out.println("Student的构造方法");
    }
    public  Student (int a,int b){
        super("老衲爱小姐",129);
        System.out.println("Student的构造方法"+a+b);
    }

    public static void main(String[] args) {
        new Student();
    }
}
//运行结果
//person的有参构造方法老衲爱尼姑12
//Student的构造方法

父类中有且只有有参构造方法时，编译器不会默认提供构造方法，此时需要在子类中显示定义有参构造方法。

🚀2.0父类中即有无参也有带参的构造器

代码示例

public class Person {
    public String name;
    public int age;
   public Person(){
      System.out.println("person的构造方法");
    }
    public Person(String name,int age){
        System.out.println("person的有参构造方法"+name+age);
    }
}

public class Student extends Person{
    public  Student (){
        System.out.println("Student的构造方法");
    }
    public  Student (int a,int b){
        System.out.println("Student的构造方法"+a+b);
    }

    public static void main(String[] args) {
        new Student();
    }
}
//运行结果
//person的构造方法
//Student的构造方法

此时编译器会默认提供无参构造器，若想调用有参直接显示调用即可。具体调用父类中的那个构造方法取决于我们的需求。

在子类构造方法中，并没有写任何关于父类的构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法，因为子类对象有两部分组成，第一部分是从父类继承过来的成员，第二部分是子类自己特有的成员。是父子关系，所以先有爸爸，然后爸爸才能生出儿子。自然在子类构造对象时，先调用父类的构造方法使其初始化，这样子类继承才有继承的成员，然后才调用自己的构造方法，将子类的自己独有的成员给初始化。

🚀2.1super总结

.若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
如果父类构造方法只有一个带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

下面为你汇总this与super关键字的异同

【相同点】

只能在类的非静态方法中使用，用来访问非静态成员方法和字段
在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点

this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
this是非静态成员方法的一个隐藏参数，super不是隐藏的参数，在成员方法的形参列表中带有当前类的this，没有super。
在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

🚀2.2再谈初始化

之前谈论的初始化是没有继承的，现在来谈谈在继承关系上的初始化顺序

代码示例

public class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类构造方法执行");
    }
    {
        System.out.println("父类实例代码块执行");
    }
    static{
        System.out.println("父类静态代码块执行");
    }

}

public class Student extends Person {

    public Student(String name, int age) {
        super(name, age);
        System.out.println("子类构造方法执行");
    }

    {
        System.out.println("子类实例代码块执行");
    }

    static {
        System.out.println("子类静态代码块执行");
    }

    public static void main(String[] args) {
        new Student("老衲爱尼姑", 19);
        System.out.println("=============");
        new Student("老衲不爱尼姑",20);
    }
}
//运行结果
//父类静态代码块执行
//子类静态代码块执行
//父类实例代码块执行
//父类构造方法执行
//子类实例代码块执行
//子类构造方法执行

通过上述代码得出一下结论

父类的静态代码块优于子类的静态代码块先执行，并静态的都是最先执行的
父类的实例代码块和构造方法紧跟其后执行
子类的实例代码块以及构造方法后执行
第二次创建子类对象时,父类与子类的静态代码块都不会执行，静态的有且只执行一次。

🚀2.3protected关键字

在类与对象中为了实现封装使用了private，同时也介绍了public以及包访问权限修饰符。现在已经学了继承，接下来就来探讨父类中不同的访问权限的成员，在子类中可见性是什么样的呢?
代码示例

package task;

public class A {
    private int a;
    public int b;
    protected int c;
    int d;
}

package task;

public class B extends A{
    public void method(){
       // super.a=12;编译报错，父类的private成员在相同的子类中不可见
        super.b=23;//类中public修饰的成员在相同的包下可以直接访问
        super.c=45;//父类中protected修饰的成员在相同的包下可以直接访问
        super.d=56;//父类中默认访问权限修饰符修饰的成员在相同的包下可以直接访问
    }
}

package task2;

import task.A;
public class C extends A {
        public void method(){
            //super.a=90;编译报错,父类private成员在不同包子类不可见
            super.b=90;//父类中public修饰的成员在不同包子类中可以直接访问
            super.c=78;//父类中protected修饰的成员在不同包的子类可以访问
            //super.d=12;
        }

}

package task2;

public class D {
    public static void main(String[] args) {
        C c=new C();
        c.method();
        System.out.println(c.b);
        //System.out.println(c.a);编译报错，父类只中private修饰的成员在不同包其它类中国不可见
        //System.out.println(c.d);父类默认的访问权限修饰符修饰的成员在不同包的其它类中无法访问。
    }
}

注意：父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了

🚀2.4访问权限修饰符的使用

权限修饰符：四种，范围由小到大(private->缺省->protect->public)

修饰符	同一个包类	同一个包中的其它类	不同包下的子类	不同包下的无关类
private	*
缺省	*	*
protect	*	*	*
public	*	*	*	*

什么时候下用哪一种呢

我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者.

因此我们在使用的时候应该尽可能的使用比较严格的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public. 另外, 还有一种简单粗暴的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用,还是具体情况具体分析, 该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用).根据实际需要来提供访问修饰限定的符。

🚀2.5继承特点

现实世界中动物上千上万，人们物种之间进行了分类。如下图所示。

在这里插入图片描述

java中继承是与现实世界高度吻合的，类与类之间也是存在伦理的，为什么这样说待我慢慢到来。

🚀2.6单继承

Java只支持单继承，不支持多继承

单继承：子类只能继承一个直接父类。支持多继承：子类不能同时继承多个父类。

代码示例

public class A {
  
}

public class C extends A,extends B {//多继承
}

为什么不支持多继承，请看反证法

public class A {
    public void method(){
        System.out.println("学习编程");
    }

}

public class B {
    public void method(){
        System.out.println("学习玩王者");
    }
}

public class C extends A, B{
    public static void main(String[] args) {
        C c=new C();
        c.method();
    }
}

如果C继承了A和B那么c.method()该调用哪个方法，该听哪个方法的。java是分不清楚的，故不支持多继承。

🚀2.7支持多层继承

这跟人类的继承关系有点类似，比如一个人有亲生父亲，必然有亲爷爷，不断的往上找，总能找到与之血脉相连的。java也是一样只是血统比较没有被稀释，因为它是无性繁殖，总能保留其父类的特性。

代码示例

public class A {//爷爷类
}

public class B extends A{//爸爸类
}

public class C extends B{//儿子类
}

C即继承了C也间接继承了A的成员。

🚀2.8继承有哪些特点？

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
java是单继承模式：一个类只能继承一个直接父类。
Java不支持多继承、但是支持多层继承。

🚀2.9final关键字

final关键字意为最终的，最后的它可以修饰变量和成员方法以及类。

1.修饰变量，表示常量(即不可修改)

final int age=19;
age=90;//编译出错

final修饰的变量需立刻初始化，否则编译不过。

2.修饰类：表示此类不能被继承

代码示例

final public class Person {
}
 public class Student extends Person{
}

被final修饰的类是无法被继承的，也就是说它成了某种意义上得太监。

3.修饰方法：表示该方法不能被重写。

代码示例

abstract public class Person {
    abstract final public void method();//该方法无法重写
}

 public class Student extends Person{
	 @Override
	 public void method() {//编译不过

	 }
}

🚀3.0继承与组合

组合也是用来描述类与类之间的关系，也能起到代码重用的效果。组合就是将一个类的实例作为另一个类的属性。

继承的表示对象之间的关系是：is-a 比如猫是一只动物。

组合表示对象之间的关系是：has -a 比如汽车有发动机,轮胎等组件。

代码示例

public class Engine {
}

public class SteeringWheel {
}
public class Tire {
}

public class Car {//组合
    private Tire tire;//轮胎
    private Engine engine;//发动机
    private SteeringWheel s;//方向盘

}

继承和组合都能是实现代码复用，一般推荐使用组合。

🚀4.0多态

概念：同类型的对象，执行同一个行为，会表现出不同的行为特征。

比如动物都会叫，但是狗是汪汪的叫，猫是喵喵的叫，比如动物都会吃东西，而狗是吃肉，猫是吃老鼠。

🚀4.1多态的实现条件

java实现多态有三大点

有继承或者实现关系
有父类引用指向子类对象
子类必须要对父类的方法进行重写。

代码示例

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

}

public class Cat extends Animal{

    public Cat(String name, int age) {
       super(name, age);
    }
}

public class Text {
    public static void main(String[] args) {
        method(new Cat("阿猫",2));
        method(new Dog("阿狗",3));
    }
    public static void method(Animal a){
        a.eat();
    }
}

运行结果
动物吃东西
动物吃东西

Dog和cat都继承了Animal，去调用eat()；方法时打印的是动物吃东西，但是动物吃东西这个行为过于模糊。我们需要的是具体的，而针对吃东西这一行为狗和猫都是不一样的，所以需要重写父类中的方法，来表现自己具体的行为。

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    @Override
    public void eat() {
     System.out.println(name+"吃老鼠");
    }

    public Cat(String name, int age) {
       super(name, age);
    }
}

public class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"吃肉");
    }
}

public class Text {
    public static void main(String[] args) {
        method(new Cat("阿猫",2));
        method(new Dog("阿狗",3));
    }
    public static void method(Animal a){
        //编译时编译器不知道该调用Dog还是Cat的eat方法
        //当程序运行时后,形参a引用的具体对象确定后，才知道调用哪个方法
        //形参的类型必须是父类类型
        a.eat();
    }
}
//运行结果
//阿猫吃老鼠
//阿狗吃肉

上述代码中method()；方法中的a调用eat()；方法时，并不知道引用a所指向的哪个类型，此时引用a调用的eat方法即可能是Dog的也可能是Cat的，那么这种吃的行为就是多态。

🚀4.2多态中成员访问特点

方法调用：编译看左边，运行看右边。

变量调用：编译看左边，运行也看左边。

重写

重写：也被称为覆盖，重写是子类中重写父类的非静态，非private修饰，非final修饰的方法，非构造方法等的实现过程进行重新编写。重写的好处在于子类能重写父类的方法，能够使子类根据本身的特点指定独有的行为。

例如下面代码

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public  Animal eat(){
        System.out.println("动物吃东西");
        return new Animal(name,age);
    }
}


public class Cat extends Animal{
    @Override
    public Cat eat() {
     System.out.println(name+"吃老鼠");
     return new Cat(name,age);
    }

    Cat(String name, int age) {
       super(name, age);
    }
}

上面的代码就是子类对父类方法的重写，可以看到子类中的eat方法与父类的方法同名，由此我们可以知道一些重写的规则。

重写的方法必须要和父类保持一致，包括返回值类型，方法名，参数列表也都要一样。如果返回值不同子类的返回值和父类的返回值必须是父子类关系，才能兼容。
重写的方法可以使用@Override注解来标识
父类被static、private修饰的方法、构造方法都不能被重写。

在来看一段代码

public class Animal {

    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    @Override
    private void eat() {//使用private后编译不过去
     System.out.println(name+"吃老鼠");
    }
}

有上述代码可知，子类中重写方法得访问权限不能低于父类中方法访问权限。

🚀4.3重写和重载的区别

区别点	重载	重写
参数列表	必须改	不能改
返回类型	可以修改	一定不能改
访问权限修饰符	可以修改	子类的访问权限修饰必须>=父类的方法的访问权限

即：方法重载是一个类多态性表现，重写是子类与父类的一种多态性表现。

🚀4.3.1静态绑定

静态绑定也被称为编译时绑定，所谓的编译时绑定就是根据用户所传入的参数就能确定具体调用哪个方法。典型代表有方法重载。

代码示例

public class Demo {
    public static void main(String[] args) {
        System.out.println(add(12, 12));
        System.out.println(add(12, 12,12));
        System.out.println(add(12, 12,34.0));
    }
    public static  int add(int a,int b){
        return a+b;
    }
    public static  int add(int a,int b,int c){
        return a+b;
    }

    public static double add(int a,int b,double c){
        return a+b+c;
    }
}

通过javap -c命令反汇编Demo.class的文件

在这里插入图片描述

🚀4.3.2动态绑定

动态绑定也被称为运行时绑定，所谓的运行时绑定，就是在编译期间是无法确定其行为，到了运行时才能确定调用哪个类的方法。

代码示例

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    @Override
    public void eat() {
     System.out.println(name+"吃老鼠");
    }

    public Cat(String name, int age) {
       super(name, age);
    }
    
    public void bark(){
        System.out.println("喵喵");
    }
}

public class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"吃肉");
    }
    public void bark(){
        System.out.println("汪汪");
    }
}

public class Text {
    public static void main(String[] args) {
        method(new Cat("阿猫",2));
        method(new Dog("阿狗",3));
    }
    public static void method(Animal a){
        //编译时编译器不知道该调用Dog还是Cat的eat方法
        //当程序运行时后,形参a引用的具体对象确定后，才知道调用哪个方法
        //形参的类型必须是父类类型
        a.eat();
    }
}

反汇编后

在这里插入图片描述

通过汇编可知编译时，调用的是Animal的eat方法，实际确实运行了Dog和Cat的方法，这里有个偷梁换柱的行为，如下图所示。

在这里插入图片描述

运行时当确定子类对象后，底层将会把子类对象的方法的引用直接覆盖掉父类的方法引用，由此就造成了多态。

🚀4.4向上转移和向下转型

🚀4.4.1向上转型

向上转型实际就是创建一个子类对象，将其当成父类对象来使用。

格式

父类类型对象名 = new 子类类型()

比如

Animal a=new Cat()；

a是Animal的引用类型，它引用了子类对象。因为Animal是动物，动物包含多种，而Cat只是其中一种。所以可以这样赋值。

【使用场景】

直接赋值
方法传参
方法返回

代码示例

public class Text {
    public static void main(String[] args) {
        //1.直接赋值
        Animal c=new Cat("阿猫",2);
        Animal d=new Dog("阿狗",3);
        method(c);
        method(d);

    }
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void method(Animal a){
        a.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗" == var){
            return new Dog("狗狗",1);
        }else if("猫" == var){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
}

向上转型的优点：让代码实现更简单灵活。向上转型的缺陷：不能调用到子类特有的方法。

🚀4.4.2向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

作用：可以解决多态下的劣势，可以实现调用子类独有的功能。

代码示例


public class Text {
    public static void main(String[] args) {
        //1.直接赋值
        Animal c=new Cat("阿猫",2);
        Animal d=new Dog("阿狗",3);
        Cat c1=(Cat)c;//向下转型
        c1.bark();
        Dog d1=(Dog)d;//向下转型
        d1.bark();
        method(c);
        method(d);

    }
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void method(Animal a){
        a.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗" == var){
            return new Dog("狗狗",1);
        }else if("猫" == var){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
}

运行结果
//喵喵
//汪汪
//阿猫吃老鼠
//阿狗吃肉

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

代码示例

public class Text {
    public static void main(String[] args) {
        //1.直接赋值
        Animal c=new Cat("阿猫",2);
        Animal d=new Dog("阿狗",3);
        Cat c2=(Cat)d;
    }
}

如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException。为了避免程序直接挂了。Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换。

变量名 instanceof 真实类型
判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。

代码示例

public class Text {

    public static void main(String[] args) {
        //1.直接赋值
        Animal c=new Cat("阿猫",2);
        Animal d=new Dog("阿狗",3);

       if(c instanceof Cat){
           Dog d1=(Dog)d;//向下转型
           d1.bark();
       }

      if((c instanceof Cat)){
          Cat c2=(Cat)c;
          c2.bark();
      }
        method(c);
        method(d);

    }
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void method(Animal a){
        a.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗" == var){
            return new Dog("狗狗",1);
        }else if("猫" == var){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
}

🚀4.5多态的优缺点

🚀4.5.1优势

1.能够降低代码的 “圈复杂度”, 避免使用大量的 if - else

什么叫 “圈复杂度” ? 圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂. 因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”. 如果一个方法的圈复杂度太高, 就需要考虑重构。

比如我们现在要打印多个形状，如果不基于多态。实现代码如下。

public class Cycle {
    public void draw(){
        System.out.println("打印cycle");
    }

}

public class Flower {
    public void draw(){
        System.out.println("打印flower");
    }
}

public class Rect {
    public void draw(){
        System.out.println("打印rect");
    }
}

public class DrewText {
    public static void main(String[] args) {
        DrawShape();
    }

    public static void DrawShape() {
        Rect r = new Rect();
        Cycle c = new Cycle();
        Flower f = new Flower();
        String[] s = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String s1 : s) {
            if (s1.equals("rect")) {
                r.draw();
            } else if (s1.equals("cycle")) {
                c.draw();
            } else if (s1.equals("flower")) {
                f.draw();
            }
        }
    }
}

如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单.

public class Shape {
    public void draw(){
        System.out.println("打印图形");
    }
}


public class Rect extends Shape{
    public void draw(){
        System.out.println("打印rect");
    }
}

public class Flower  extends Shape{
    public void draw(){
        System.out.println("打印flower");
    }
}

public class Cycle  extends Shape{
    public void draw(){
        System.out.println("打印cycle");
    }

}

public class DrawText2 {
    public static void main(String[] args) {
        DrawShape();
    }
    public static void DrawShape(){
   Shape [] s={new Cycle(),new Flower(),new Rect(),new Cycle()};
        for (Shape shape : s) {
            shape.draw();
        }
    }
}

可扩展能力更强

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

public class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("△");
    }
}

只需要将新的对象调到到数组里面即可，而用不用 if -else 则需要对if else 修改.

🚀4.5.2劣势

多态下不能使用子类的独有功能
代码执行效率低

最后的话

各位看官如果觉得文章写得不错，点赞评论关注走一波！谢谢啦！

在这里插入图片描述