Java多态详解

学习完封装和继承之后,我们现在来学习多态,多态是需要建立在学习完封装和继承的基础上.这三个是面向对象最重要的是三个特性.

那什么是多态呢?

多态是一种能够实现动态编译的方法,即同一方法可以根据发送对象的不同而采用多种不同的行为方式,这里我们要知道,一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多(父类,其他相关类),需要注意的是:多态的存在是建立在方法重写了的基础上的.

怎么才能使用多态呢(多态存在的条件)?

1.首先我们需要先知道,多态是指方法的多态,属性是没有多态性的

2.方法所属类之间需要有父子继承关系(Student-->Person),否则会报类型转换异常(ClassCastException)错误

3.子类重写了父类方法 @Override

4.父类引用指向了子类对象 Father f1 = new Son();

我们来看一段代码理解:

首先是实现类(Application):

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        new Student();
        new Person();
        //他可以指向的引用类型就不确定了
        //Student子类能调用的方法都是自己独有的和继承父类的
        Student s1 = new Student();//子类的引用指向子类
        //Person父类可以指向子类,但不能调用子类独有的方法
        Person s2 = new Student();//父类的引用指向子类
        //对象能执行哪些方法,主要看对象左边的类型和右边关系不大

        s2.run();//son run 若子类重写了父类的方法,执行子类的方法
        s1.run();//son run 调用子类的run方法
        //s2.eat();父类不能直接调用子类独有的方法eat,如需调用需强转类
        ((Student)s2).eat();//son eat 把S2的Person类强制转换成Student类
        s1.eat();//son eat 调用子类独有的eat方法
    }
}

然后是子类(Student):

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

最后是父类(Person):

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

结合上面的代码,我们可以知道多态的存在可以让我们的程序更灵活,能实现更多不同的效果,最后总结一下子类和父类的引用之间的关系:

首先我们要知道,对象能执行哪些方法,主要看对象左边的类型,跟对象右边没什么关系.

1.子类继承父类,并重写了相同方法时,无论调用的是父类还是子类,执行的都是子类重写的方法.

2.子类继承父类,子类有自己独特的方法时,可以在子类中直接调用,但在父类中是不可以直接调用的,需要将父类的类型强制转换成子类,才能调用子类中特有的方法.

多态可以用来做什么呢?

我们前面说到的:同一方法可以根据发送对象的不同而采用多种不同的行为方式,多态多态,可以理解为同一个父类的不同子类对于父类的方法有不同的"形态";打个比方,现在有一个父类Animal,有子类Cat,Dog等,在父类中有方法eat()方法提示"吃东西",那在子类Cat中就可以重写方法eat()方法体为"吃小鱼干";在子类Dog中就可以重写方法eat()方法体为"吃骨头",这样子类的功能可以被​​​​​​​调用类的方法或引用变量所调用,这叫向后兼容,可以提高代码的可扩充性和可维护性. 这样代码就不必为每一个子类编写功能调用,只需要对引用类进行处理即可.这样可以大大提高程序的可复用性。

对多态有了基本的了解之后,我们来延伸一下上面说到的类转换,这个跟java数据类型的转换是很相像的,也是包括自动转换和强制转换.在数据类型和类的转换中,低转高都是可以自动转换的,而高转低需要强制转换:在数据类型的强制转换中会影响精度,而在类的强制转换中,则会出现丢失方法的可能.来看代码实现:

​​​​​​​

public class Application {
    public static void main(String[] args) {
        //类型之间的转化: 父(高) --> 子(低)
        //高      <--       低
        Person obj = new Student();//低转高,自动转换
        //student将这个对象转换成Student类型,我们就可以使用Student类型的方法了
        Student student = (Student) obj;//高转低,强制转换
        student.go();
        //子类转换为父类,可能丢失自己本来的一些方法!
    }
}

这里又在引入一个新的关键字:instanceof(),它可以判断两个类之间是否存在父子或相等关系: X instanceof Y 他的底层逻辑是先判断X类能不能转换成Y类,如果转换不了,则编译失败,如果能转换,再判断X是否是Y的本类或者子类,最后输出boolean结果.我们来看看具体的代码实现:

//Object > String
//Object > Person > Student;
//Object > Person > Teacher;

//System.out.println(X instanceof Y);//先判断X是否能转换成Y,再判断X是否是Y的本类或者子类.

Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("========================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译报错!
System.out.println("========================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译报错
//System.out.println(student instanceof String);//编译报错

最后我们做个简单的总结:

1.父类引用可以指向子类的对象,而子类引用不能指向父类的对象
2.把子类转换成父类,向上转型;
3.把父类转换成子类,向下转向,需要强制转换,可能会丢失自己本来的一些方法
4.方便方法的调用,减少重复的代码,有效提升利用率
5.抽象的编程思想 : 封装,继承,多态!  抽象类 接口