[Java入门] 多态

最新推荐文章于 2025-05-16 16:31:39 发布

DerrictC

最新推荐文章于 2025-05-16 16:31:39 发布

阅读量762

点赞数 20

CC 4.0 BY-SA版权

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/DerrictC/article/details/146421913

[Java入门] 多态

多态

多态

1. 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

2. 多态的实现条件

实现多态有三个必要条件，缺一不可：

向上转型
方法重写
通过父类引用，调用子类对象重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应该类中重写的方法。

class Person{
    public String name;
    public int age;

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

    public void play(){
        System.out.println(name + " 在玩！");
    }

}

class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println(name + " 在打篮球！");
    }

    public void study() {
        System.out.println(name + " 在学习！");
    }
}

class Employee extends Person{
    public Employee(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println(name + " 在团建！");
    }

    public void work() {
        System.out.println(name + " 在工作！");
    }
}

public class Main {
    public static void play(Person person) {
        person.play();
    }

    public static void main(String[] args) {
        Student student = new Student("小明", 15);
        Employee employee = new Employee("小兰", 25);

        //传递不同对象，会调用不同对象重写的方法
        play(student); //结果： 小明在打篮球！
        play(employee); //结果： 小兰在团建！
    }

阅读上述代码，可明显看出当传递不同类对象时，会调用对应该类中重写的方法。而发生这种情况的原理就是 ‘向上转型’

3. 向上转型

3.1 向上转型

所谓向上转型，即就是实例化一个子类对象，把它当作父类对象来使用。

那怎么构成向上转型呢？我们参考上面代码，通过创建 Student类和 Employee类的引用 student 和 employee，传参给形参为它们父类 Person类的play方法，通过调用play方法便实现了向上转型。

所以，我们可以推出向上转型的语法格式：父类类型对象名 = new 子类类型()

Person person1 = new Student("小明", 15);
Person person2 = new Employee("小兰", 25);

可见，向上转型是从小范围向大范围转移。

3.2 发生向上转型的方式

发生向上转型的方式有3种：

直接赋值

Person person1 = new Student("小明", 15);
Person person2 = new Employee("小兰", 25);

方法传参

public static void main(String[] args) {
        Student student = new Student("小明", 15);
        Employee employee = new Employee("小兰", 25);
        
        func1(student); 
        func1(employee);
    }

    public static void func1(Person person) {
        
    }

看完代码后，也许会有点眼熟，没错！与前面的代码是类似的，它们都是通过方法传参的方式实现向上转型的。

返回值

    public static void main(String[] args) {

        //两个方法通过返回值都能实现向上转型
        //但是 func2 不够灵活， 因为 func2 的返回值只能是 Student类型
        //而 func3 的返回值就能返回 Person类 的所有子类类型
        //因此 func3 更加灵活, 一般建议多使用 func3 这种方式！
        Person person1 = func2();
        Person person2 = func3();
    }

    public static Student func2(){
        return new Student("小明", 15);
    }

    public static Person func3(){
        return new Student("小明", 15);
    }

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

3.3 向下转型

所谓向下转型，即将父类引用再还原为子类对象。
我们将子类对象向上转型后就不能再使用子类特有的方法了，但是，有时我们需要调用子类特有的方法，那么仅需将向上转型后的子类对象再次强转为子类引用，就可以使用子类特有的方法了，这就是向下转型。

public static void main(String[] args) {

      Person person1 = new Student("小明", 15);
      //person1.study(); 报错 向上转型后无法再调用子类特有方法！
      
      Student student = (Student) person1;
      student.study(); // 向下转型后 便可再次调用子类特有方法了！
      
  }

向下转型还有一个需要注意的点，就是再次强转的类型一定是与向上转型前的类型一致，否则会报错。
通俗点讲，就是你原来是学生，不可能后面变回来就不再是学生了。

这就体现出了向下转型的不安全，所以Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

instanceof 关键字主要用法就是用于判断前者是否引用了后者

    public static void main(String[] args) {

        Person person1 = new Student("小明", 15);
        Employee employee = (Employee) person1;
        //employee.work();//运行报错 java.lang.ClassCastException：class Student cannot be cast to class Employee

        Person person2  = new Employee("小兰", 25);
        if(person2 instanceof Student) {
            Student student = (Student) person2;
            student.study();
        }else {
            System.out.println("我已经上班很久了！！！！");
        }
		//一般进行向下转型前都需用instanceof判断
    }

4. 方法重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

4.1 方法重写的规则

在子类重写父类方法时，一般要求外壳不变，即方法名、参数列表和返回值类型要完全相同
若子类与父类构成继承关系，那么返回值类型可以不同，但必须具有父子关系
若方法被static、private修饰或者是构造方法，则此方法不可重写
方法的访问权限不能比父类中被重写的方法访问权限更低。如，若父类方法被public修饰，那么在子类重写的方法是不能用protected 或 default 修饰，可以用public修饰
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

4.2 重写和重载的区别

在这里插入图片描述
即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

方法重载

class A {
    public void B(int n){
        System.out.println(n);
    }

    public int B(int n,int m){
        return n+m;
    }
}

public static void main(String[] args) {
        int n = 10;
        int m = 20;
        A a = new A();
        a.B(n);
        System.out.println(a.B(n, m));
    }
//结果：
//10
//30

方法重写

class Person{
    public String name;
    public int age;

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

    public void play(){
        System.out.println(name + " 在玩！");
    }

}

class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println(name + " 在打篮球！");
    }
}
//结果：小明 在打篮球！

[两种绑定]

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表方法重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。典型代表方法重写。

5. 避免在构造方法中调用重写的方法

class B{
    public B() {
        func();
    }

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

class C extends B{
    public int c = 10;

    public void func(){
        System.out.println("C.func() " + c);
    }
}

public class test {
    public static void main(String[] args) {
        C c = new C();
    }
}

//结果：C.func() 0