🎉🎉🎉欢迎来到我的博客,我是一名自学了2年半前端的大一学生,熟悉的技术是JavaScript与Vue.目前正在往全栈方向前进, 如果我的博客给您带来了帮助欢迎您关注我,我将会持续不断的更新文章!!!🙏🙏🙏

@[toc]

1. 封装

1.1 封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

1.2 封装的步骤实现

private修饰成员变量

public class Student {
   
    private String name;
    private int age;
}

public修饰getter和setter方法

public class Student {
   
    private String name;
    private int age;

    public void setName(String n) {
   
          name = n;
    }

    public String getName() {
   
          return name;
    }

    public void setAge(int a) {
   
        if (a > 0 && a <200) {
   
            age = a;
        } else {
   
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
   
          return age;
    }
}

2. 继承

2.1 概述

2.1.1 引入

假如我们要定义如下类:
学生类,老师类和工人类，分析如下。

学生类
属性:姓名,年龄
行为:吃饭,睡觉
老师类
属性:姓名,年龄，薪水
行为:吃饭,睡觉，教书
班主任
属性:姓名,年龄，薪水
行为:吃饭,睡觉，管理

如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息（属性:姓名，年龄。行为：吃饭，睡觉）。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）或者基类。

2.1.2 继承的含义

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

2.1.3 继承的好处

提高代码的复用性（减少代码冗余，相同代码重复利用）。
使类与类之间产生了关系。

2.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
   
    ...
}

class 子类 extends 父类 {
   
    ...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

2.3 继承案例

2.3.1 案例

请使用继承定义以下类:

学生类
属性:姓名,年龄
行为:吃饭,睡觉
老师类
属性:姓名,年龄，薪水
行为:吃饭,睡觉，教书
班主任
属性:姓名,年龄，薪水
行为:吃饭,睡觉，管理

2.3.2 案例图解分析

老师类，学生类，还有班主任类，实际上都是属于人类的，我们可以定义一个人类，把他们相同的属性和行为都定义在人类中，然后继承人类即可，子类特有的属性和行为就定义在子类中了。

如下图所示。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.3.3 案例代码实现

1.父类Human类

 public class Human {
   
    // 合理隐藏
    private String name ;
    private int age ;

    // 合理暴露
    public String getName() {
   
        return name;
    }

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

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }
 }

2.子类Teacher类

public class Teacher extends Human {
   
    // 工资
    private double salary ;

    // 特有方法
    public void teach(){
   
        System.out.println("老师在认真教技术！")；
    }

    public double getSalary() {
   
        return salary;
    }

    public void setSalary(double salary) {
   
        this.salary = salary;
    }
}

3.子类Student类

public class Student extends Human{
   

}

4.子类HeadTeacher类

public class HeadTeacher extends Human {
   
    // 工资
    private double salary ;

       // 特有方法
    public void admin(){
   
        System.out.println("班主任强调纪律问题！")；
    }

    public double getSalary() {
   
        return salary;
    }

    public void setSalary(double salary) {
   
        this.salary = salary;
    }
}

5.测试类

  public class Test {
   
      public static void main(String[] args) {
   
          Teacher dlei = new Teacher();
          dlei.setName("张三");
          dlei.setAge("31");
          dlei.setSalary(1000.99);
          System.out.println(dlei.getName());
          System.out.println(dlei.getAge());
          System.out.println(dlei.getSalary());
          dlei.teach();

          HeadTeacher linTao = new HeadTeacher();
          linTao.setName("李四");
          linTao.setAge("28");
          linTao.setSalary(1000.99);
          System.out.println(linTao.getName());
          System.out.println(linTao.getAge());
          System.out.println(linTao.getSalary());
          linTao.admin();

          Student xugan = new Student();
          xugan.setName("王五");
          xugan.setAge("31");
          //xugan.setSalary(1000.99); // xugan没有薪水属性，报错！
          System.out.println(xugan.getName());
          System.out.println(xugan.getAge());

      }
  }

2.3.4 小结

1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

2.子类继承父类，就可以直接得到父类的成员变量和方法。是否可以继承所有成分呢？请看下节！

2.4 子类不能继承的内容

2.4.1 引入

并不是父类的所有内容都可以给子类继承的：

子类不能继承父类的构造器，因为子类有自己的构造器。

值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

2.4.2 演示代码

public class Demo03 {
   
    public static void main(String[] args) {
   
        Zi z = new Zi();
        System.out.println(z.num1);
//        System.out.println(z.num2); // 私有的子类无法使用
        // 通过getter/setter方法访问父类的private成员变量
        System.out.println(z.getNum2());

        z.show1();
        // z.show2(); // 私有的子类无法使用
    }
}

class Fu {
   
    public int num1 = 10;
    private int num2 = 20;

    public void show1() {
   
        System.out.println("show1");
    }

    private void show2() {
   
        System.out.println("show2");
    }

    public int getNum2() {
   
        return num2;
    }

    public void setNum2(int num2) {
   
        this.num2 = num2;
    }
}

class Zi extends Fu {
   
}

2.5 继承后的特点

2.5.1 成员变量

2.5.1.1 成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
   
    // Fu中的成员变量
    int num = 5;
}
class Zi extends Fu {
   
    // Zi中的成员变量
    int num2 = 6;

    // Zi中的成员方法
    public void show() {
   
        // 访问父类中的num
        System.out.println("Fu num="+num); // 继承而来，所以直接访问。
        // 访问子类中的num2
        System.out.println("Zi num2="+num2);
    }
}
class Demo04 {
   
    public static void main(String[] args) {
   
        // 创建子类对象
        Zi z = new Zi(); 
          // 调用子类中的show方法
        z.show();  
    }
}

演示结果：
Fu num = 5
Zi num2 = 6

2.5.1.2 成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu1 {
   
    // Fu中的成员变量。
    int num = 5;
}
class Zi1 extends Fu1 {
   
    // Zi中的成员变量
    int num = 6;

    public void show() {
   
        // 访问父类中的num
        System.out.println("Fu num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + num);
    }
}
class Demo04 {
   
    public static void main(String[] args) {
   
          // 创建子类对象
        Zi1 z = new Zi1(); 
          // 调用子类中的show方法
        z1.show(); 
    }
}
演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢？我们可以使用super关键字。

2.5.1.3 super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于 this 。

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用。

使用格式：

super.父类成员变量名

子类方法需要修改，代码如下：

class Fu {
   
    // Fu中的成员变量。
    int num = 5;
}

class Zi extends Fu {
   
    // Zi中的成员变量
    int num = 6;

    public void show() {
   
        int num = 1;

        // 访问方法中的num
        System.out.println("method num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + this.num);
        // 访问父类中的num
        System.out.println("Fu num=" + super.num);
    }
}

class Demo04 {
   
    public static void main(String[] args) {
   
          // 创建子类对象
        Zi1 z = new Zi1(); 
          // 调用子类中的show方法
        z1.show(); 
    }
}

演示结果：
method num=1
Zi num=6
Fu num=5

小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

2.5.2 成员方法

2.5.2.1 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

class Fu {
   
    public void show() {
   
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
   
    public void show2() {
   
        System.out.println("Zi类中的show2方法执行");
    }
}
public  class Demo05 {
   
    public static void main(String[] args) {
   
        Zi z = new Zi();
         //子类中没有show方法，但是可以找到父类方法去执行
        z.show(); 
        z.show2();
    }
}

2.5.2.2 成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

代码如下：

class Fu {
   
    public void show() {
   
        System.out.println("Fu show");
    }
}
class Zi extends Fu {
   
    //子类重写了父类的show方法
    public void show() {
   
        System.out.println("Zi show");
    }
}
public class ExtendsDemo05{
   
    public static void main(String[] args) {
   
        Zi z = new Zi();
         // 子类中有show方法，只执行重写后的show方法
        z.show();  // Zi show
    }
}

2.5.3 构造器

2.5.3.1 引入

当类之间产生了关系，其中各类中的构造器，又产生了哪些影响呢？
首先我们要回忆两个事情，构造器的定义格式和作用。

构造器的名字是与类名一致的。所以子类是无法继承父类构造方法的。
构造器的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）

继承后子类构造器特点:子类所有构造器的第一行都会先调用父类的无参构造器，再执行自己

2.5.3.2 案例演示

按如下需求定义类:

人类
成员变量: 姓名,年龄
成员方法: 吃饭
学生类
成员变量: 姓名,年龄,成绩
成员方法: 吃饭

代码如下：

class Person {
   
    private String name;
    private int age;

    public Person() {
   
        System.out.println("父类无参");
    }

    // getter/setter省略
}

class Student extends Person {
   
    private double score;

    public Student() {
   
        //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }

     public Student(double score) {
   
        //super();  // 调用父类无参,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }

}

public class Demo07 {
   
    public static void main(String[] args) {
   
        Student s1 = new Student();
        System.out.println("----------");
        Student s2 = new Student(99.9);
    }
}

输出结果：
父类无参
子类无参
----------
父类无参
子类有参

2.5.3.3 小结

子类构造器执行的时候，都会在第一行默认先调用父类无参数构造器一次。
子类构造器的第一行都隐含了一个super()去调用父类无参数构造器，super()可以省略不写。

2.6 方法重写

2.6.1 概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

2.6.2 使用场景和案例

发生在子父类之间的关系。
子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方法。

例如：我们定义了一个动物类代码如下：

public class Animal  {
   
    public void run(){
   
        System.out.println("动物跑的很快！");
    }
    public void cry(){
   
        System.out.println("动物都可以叫~~~");
    }
}

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求

代码如下：

public class Cat extends Animal {
   
    public void cry(){
   
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}

public class Test {
   
    public static void main(String[] args) {
   
          // 创建子类对象
          Cat ddm = new Cat()；
        // 调用父类继承而来的方法
        ddm.run();
          // 调用子类重写的方法
          ddm.cry();
    }
}

2.6.3 @Override重写注解

@Override:注解，重写注解校验！
这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

加上后的子类代码形式如下：

public class Cat extends Animal {
     
     // 声明不变，重新实现
    // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    @Override
    public void cry(){
     
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}

2.6.4 注意事项

方法重写是发生在子父类之间的关系。
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

2.7 super(...)和this(...)

2.7.1 引入

class Person {
   
    private String name;
    private int age;

    public Person() {
   
        System.out.println("父类无参");
    }

    // getter/setter省略
}

class Student extends Person {
   
    private double score;

    public Student() {
   
        //super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }

     public Student(double score) {
   
        //super();  // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }
      // getter/setter省略
}

public class Demo07 {
   
    public static void main(String[] args) {
   
        // 调用子类有参数构造器
        Student s2 = new Student(99.9);
        System.out.println(s2.getScore()); // 99.9
        System.out.println(s2.getName()); // 输出 null
        System.out.println(s2.getAge()); // 输出 0
    }
}

我们发现，子类有参数构造器只是初始化了自己对象中的成员变量score，而父类中的成员变量name和age依然是没有数据的，怎么解决这个问题呢，我们可以借助与super(...)去调用父类构造器，以便初始化继承自父类对象的name和age.

2.7.2 super和this的用法格式

super和this完整的用法如下:

this.成员变量        --    本类的
super.成员变量        --    父类的

this.成员方法名()      --    本类的    
super.成员方法名()   --    父类的

接下来我们使用调用构造器格式：

super(...) -- 调用父类的构造器，根据参数匹配确认
this(...) -- 调用本类的其他构造器，根据参数匹配确认

2.7.3 super(....)用法演示

代码如下：

class Person {
   
    private String name ="凤姐";
    private int age = 20;

    public Person() {
   
        System.out.println("父类无参");
    }

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

    // getter/setter省略
}

class Student extends Person {
   
    private double score = 100;

    public Student() {
   
        //super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }

     public Student(String name ， int age，double score) {
   
        super(name ,age);// 调用父类有参构造器Person(String name , int age)初始化name和age
        this.score = score;    
        System.out.println("子类有参");
     }
      // getter/setter省略
}

public class Demo07 {
   
    public static void main(String[] args) {
   
        // 调用子类有参数构造器
        Student s2 = new Student("张三"，20，99);
        System.out.println(s2.getScore()); // 99
        System.out.println(s2.getName()); // 输出 张三
        System.out.println(s2.getAge()); // 输出 20
    }
}

注意：

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super(..)是根据参数去确定调用父类哪个构造器的。

2.7.4 super(...)案例图解

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造器调用时，一定先调用父类的构造器。理解图解如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.7.5 this(...)用法演示

默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
为了借用其他构造器的功能。

package com.itheima._08this和super调用构造器;
/**
 * this(...):
 *    默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
 *    为了借用其他构造器的功能。
 *
 */
public class ThisDemo01 {
   
    public static void main(String[] args) {
   
        Student xuGan = new Student();
        System.out.println(xuGan.getName()); // 输出:徐干
        System.out.println(xuGan.getAge());// 输出:21
        System.out.println(xuGan.getSex());// 输出： 男
    }
}

class Student{
   
    private String name ;
    private int age ;
    private char sex ;

    public Student() {
   
  // 很弱，我的兄弟很牛逼啊，我可以调用其他构造器：Student(String name, int age, char sex)
        this("徐干",21,'男');
    }

    public Student(String name, int age, char sex) {
   
        this.name = name ;
        this.age = age   ;
        this.sex = sex   ;
    }

    public String getName() {
   
        return name;
    }

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

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }

    public char getSex() {
   
        return sex;
    }

    public void setSex(char sex) {
   
        this.sex = sex;
    }
}

2.7.6 小结

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
super(..)和this(...)是根据参数去确定调用父类哪个构造器的。
super(..)可以调用父类构造器初始化继承自父类的成员变量的数据。
this(..)可以调用本类中的其他构造器。

2.8 继承的特点

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

// 一个类只能有一个父类，不可以有多个父类。
class A {
     }
class B {
     }
class C1 extends A {
     } // ok
// class C2 extends A, B {} // error

一个类可以有多个子类。

// A可以有多个子类
class A {
     }
class C1 extends A {
     }
class C2 extends  A {
     }

可以多层继承。

class A {
     }
class C1 extends A {
     }
class D extends C1 {
     }

顶层父类是Object类。所有的类默认继承Object，作为父类。

3. 多态

3.1 多态的形式

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

多态体现的格式：

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

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

3.2 多态的案例演示

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

总结起来就是：编译看左边，运行看右边。

代码如下：

定义父类：

public class Animal {
     
    public void eat()｛
        System.out.println("动物吃东西！")
    ｝
}

定义子类：

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

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

定义测试类：

public class Test {
   
    public static void main(String[] args) {
   
        // 多态形式，创建对象
        Animal a1 = new Cat();
        // 调用的是 Cat 的 eat
        a1.eat();

        // 多态形式，创建对象
        Animal a2 = new Dog();
        // 调用的是 Dog 的 eat
        a2.eat();
    }  
}

3.3 多态的定义和前提

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

从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。

前提【重点】

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

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

3.4 多态的好处

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

定义父类：

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

定义子类：

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

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

定义测试类：

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都可以完成。从而实现了实现类的自动切换。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

3.5 多态的弊端

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

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没有这个方法
    }
}

3.5 引用类型转换

3.5.1 为什么要转型

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

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

回顾基本数据类型转换

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

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

3.5.2 向上转型（自动转换）

向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：

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

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

3.5.3 向下转型（强制转换）

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

使用格式：

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

3.5.4 案例演示

转型演示，代码如下：

定义类：

abstract class Animal {
     
    abstract void eat();  
}  

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("吃骨头");  
    }  
    public void watchHouse() {
     
        System.out.println("看家");  
    }  
}

定义测试类：

public class Test {
   
    public static void main(String[] args) {
   
        // 向上转型  
        Animal a = new Cat();  
        a.eat();                 // 调用的是 Cat 的 eat

        // 向下转型  
        Cat c = (Cat)a;       
        c.catchMouse();         // 调用的是 Cat 的 catchMouse
    }  
}

3.5.5 转型的异常

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

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对象的。

3.5.6 instanceof关键字

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

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

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

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
        }
    }  
}

Hi👋,这里是瑞雨溪一个喜欢JavaScript和Vue的大学生,如果我的文章给你带来的帮助,欢迎您关注我,我会持续不断的更新更多优质文章.你的关注就是我的动力!!!🎉🎉🎉

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

还不明白面向对象？ 本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）

1. 封装

1.1 封装的步骤

1.2 封装的步骤实现

2. 继承

2.1 概述

2.1.1 引入

2.1.2 继承的含义

2.1.3 继承的好处

2.2 继承的格式

2.3 继承案例

2.3.1 案例

2.3.2 案例图解分析

2.3.3 案例代码实现

2.3.4 小结

2.4 子类不能继承的内容

2.4.1 引入

2.4.2 演示代码

2.5 继承后的特点

2.5.1 成员变量

2.5.1.1 成员变量不重名

2.5.1.2 成员变量重名

2.5.1.3 super访问父类成员变量

2.5.2 成员方法

2.5.2.1 成员方法不重名

2.5.2.2 成员方法重名

2.5.3 构造器

2.5.3.1 引入

2.5.3.2 案例演示

2.5.3.3 小结

2.6 方法重写

2.6.1 概念

2.6.2 使用场景和案例

2.6.3 @Override重写注解

2.6.4 注意事项

2.7 super(...)和this(...)

2.7.1 引入

2.7.2 super和this的用法格式

2.7.3 super(....)用法演示

2.7.4 super(...)案例图解

2.7.5 this(...)用法演示

2.7.6 小结

2.8 继承的特点

3. 多态

3.1 多态的形式

3.2 多态的案例演示

3.3 多态的定义和前提

3.4 多态的好处

3.5 多态的弊端

3.5 引用类型转换

3.5.1 为什么要转型

3.5.2 向上转型（自动转换）

3.5.3 向下转型（强制转换）

3.5.4 案例演示

3.5.5 转型的异常

3.5.6 instanceof关键字

热门文章

最新文章

相关课程

相关电子书

相关实验场景

还不明白面向对象？本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）