[Java入门] 多态

多态

1. 多态的概念

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

2. 多态的实现条件

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

  1. 向上转型
  2. 方法重写
  3. 通过父类引用,调用子类对象重写的方法

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

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种:

  1. 直接赋值
Person person1 = new Student("小明", 15);
Person person2 = new Employee("小兰", 25);
  1. 方法传参
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) {
        
    }

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

  1. 返回值
    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

看到结果后,有人可能觉得疑惑为什么不是 C.func() 10 呢?这就是因为构造方法没有多态性。

我们先来解释一下上述代码的运行步骤:

  • 首先在main方法中构造了c对象,由于继承关系,会先调用父类 即B的构造方法
  • 然后在B的构造方法中调用了func方法,由于子类C重写了func方法,那么就会直接调用子类C中的func方法
  • 由于是直接调用C的func方法,变量c并未初始化为10,而是存储着未初始化状态下的默认值0,最后打印结果 C.func() 0 ,这是不具有多态性的情况
  • 若构造方法存在多态性,就会直接调用子类构造对c初始化,结果就为C.func 10
  • 所以,在构造函数内,尽量避免使用实例方法,除了final和private方法。

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

本期内容到这就结束了,欢迎大家多多提出疑问 或 内容存在的问题!!!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值