关于java的多态

关于java的多态

我们在上一篇文章中，了解了方法的重写，以及super的使用方法和含义，我们本篇文章来了解一下面向对象最后一个特性，多态😀，它可以实现动态变量。

一、面向对象理解顺序

首先我们学习面向对象的时候，一定要注意学习顺序，不要跳着学习，要逐步渗透，下面我把顺序列出来，一步一步学习然后再了解多态。

1、关于java的封装

2、关于java的继承

3、关于java中的Super详解

4、关于java的方法重写

5、关于java的多态

二、多态

• 动态编译：类型：可扩展性。

1、我们还是老样子，新建一个软件包，在里面新建一个人类和学生类，让学生类继承人类。

package oop.Demo07;

public class Person 
{
    public void run()
    {
        System.out.println("run");
    }
}

package oop.Demo07;

public class Student extends Person
{

}

2、我们在main方法中，调用哪个类，就是哪个类。

import oop.Demo07.Person;
import oop.Demo07.Student;

public class Application {
    public static void main(String[] args)
    {
        //一个对象的实际类型是确认的
        new Person();
        new Student();
    }
}

所以我们可以发现，一个对象的实际类型是确认的。

import oop.Demo07.Person;
import oop.Demo07.Student;

public class Application {
    public static void main(String[] args)
    {
        new Person();
        new Student();
		//可以指向的引用类型不确定：父类的引用指向子类
        Student s1 = new Student();
        Person p1 = new Student();
        Object o1 = new Student();//Object是Person的父类
    }
}

通过引用，我们也可以得出一个结论：可以指向的引用类型不确定：父类的引用指向子类。

import oop.Demo07.Person;
import oop.Demo07.Student;

public class Application {
    public static void main(String[] args)
    {
        Student s1 = new Student();
        Person p1 = new Student();
        Object o1 = new Student();
        p1.run();
    }
}

我们在父类中，写了run方法，我们执行以下代码，因为p1是new的Person类，引用的Person类，所以输出的方法是Person中的方法。

run

我们在子类中，重写父类的方法，ctrl+O。

package oop.Demo07;

public class Student extends Person
{
    @Override
    public void run() 
    {
       System.out.println("son");
    }
}

我们再来用Student引用的类去调用一下。

import oop.Demo07.Person;
import oop.Demo07.Student;

public class Application 
{
    public static void main(String[] args)
    {
        Student s1 = new Student();
        Person p1 = new Student();
        Object o1 = new Student();
        p1.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}

我们发现执行的结果是Student中重写的方法，子类重写了父类的方法，执行子类的方法。

son
son

如果再定义一个方法，在Student类中，定义一个eat方法，Person中没有这个方法。

package oop.Demo07;

public class Student extends Person
{
    @Override
    public void run() 
    {
       System.out.println("son");
    }
    
    public void eat()
    {
        System.out.println("eat");
    }
}

我们调用的时候，发现Student引用的类可以直接调用，但是父类Person不可以直接调用，但是可以用一种别的办法调用。

public class Application 
{
    public static void main(String[] args)
    {
        Student s1 = new Student();
        Person p1 = new Student();
        Object o1 = new Student();
        p1.run();
        ((Student) p1).eat();//编译器会自动帮我们转换方式
        s1.eat();//自己调用，没问题
    }
}

• 子类没有重写父类，调用的就是父类的方法。
• 子类重写父类，调用的就是子类的方法。
• 对象能执行那些方法，主要看对象左边的类型，和右边的关系不大。

Student s1 = new Student();
//Student能调用的方法，都是自己的或者继承父类的。

Person p1 = new Student();
//Person是父类，虽然可以指向子类，但是不能调用子类独有的方法。

((Student) p1).eat();
//强制转换类型，高类型转低类型。

三、多态注意事项

• 多态是方法的多态，属性没有多态。

• 父类和子类，有联系，不能随意转换，比如String类型转成刚刚咱们的Person类型，这肯定是不行的😊

• 类型不对应，编译器会报错，类型转换异常（ClassCastException）！

• 多态存在的条件：

  1、继承关系。

  2、方法的重写。

  3、父类的引用，指向的是子类。

• 但是有些方法不能被重写：

  1、static方法，属于类不属于实例。

  2、final 常量。

  3、private方法，私有方法不能重写。

四、总结

• 同一方法，可以根据发送对象的不同采用多种不同的行为方式。
• 一个对象的实际类型是确定的，但是可以指向对象的引用类型会很多（父类或者有关系的类）。
• instanceof关键词（类型转换）：引用类型之间的转换，我们放在以后详细介绍。