面向对象之多态（向上转型与向下转型）

多态的分类

什么是多态：同一个行为具有多个不同表现形式或形态的能力就是多态。

多态一般分为两种：

重写式多态和重载式多态。

重载式多态，也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。

这种多态通过函数的重写以及向上转型来实现，我们上面代码中的例子就是一个完整的重写式多态。

多态的条件

(1)继承:在多态中必须存在有继承关系的子类和父类。
(2)重写:子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
(3)向上转型:在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
继承也可以替换为实现接口。

对象的向上转型

对象的向上转型：父类父类对象 = 子类实例

package test1;

class Person{

   String  name="tom";

    public void print()

    {

        System.out.println("我是人");

    }

    public void car()

    {

        System.out.println("劳斯莱斯");

    }

}

class Student extends Person{

   String  name="tomcat";

    public void print()

    {

        System.out.println("我是学生");

    }

    public void house()

    {

        System.out.println("别墅");

    }

}

public class TestCollection{

    public static void main(String[] args)

    {

        //向上转型 父类 父类对象 = 子类实例

       /*1.父类有的方法，都可以调用，如果被子类重写了，则会调用子类的方法。

        *2. 父类没有的方法，而子类存在，则不能调用。

        *3.向上转型只对方法有影响，对属性没影响。属性不存在重写。*/

        Person per = new Student();

        Student  st=new Student();

        per.print();

        per.car();

}
}

输出：

为什么要发生向上转型？

减少重复代码，使代码变得简洁。
提高系统扩展性。
用于参数统一化,假设父类有n个子类，方法要接受子类的实例，如果没有向上转型，就需要定义n个方法接收不同的对象。

对象的向下转型

对象的向下转型：子类子类对象 = （子类）父类实例为什么要发生向下转型？当父类需要调用子类的扩充方法时，才需要向下转型。

class Person{
public void print()
{
System.out.println("我是人");
}
}
class Student extends Person{
public void print()
{
System.out.println("我是学生");
}
public void fun()
{
System.out.println("开心的一天！");
}
}
public class Test{
public static void main(String[] args)
{
//向上转型 父类 父类对象 = 子类实例
Person per = new Student();
/**
运用向上转型后，此时若想访问子类中的fun方法是不可以的，
所以就有了向下转型。
*/
Student stu = (Student)per;
stu.fun();
}
}

  向下转型之前一定要进行向上转型！！
否则在转型时会出现ClassCastException（类型转换异常–运行时异常）
问题： 如果向下转型存在安全隐患，那么如何转型才靠谱？
   先判断在转型（依靠instanceof关键字实现）引用名 instanceof 类 表示该引用是否能表示该类实例，返回boolean类型。class Person{public void print()

{
System.out.println("我是人");
}
public void p()
{
System.out.println("伤心的一天");
}
}
class Student extends Person{
public void print()
{
System.out.println("我是学生");
}
public void fun()
{
System.out.println("开心的一天！");
}
}
public class Test{
public static void main(String[] args)
{
Person per = new Student();
//per是否能表示Person实例
System.out.println(per instanceof Person);
//per是否能表示Student实例
System.out.println(per instanceof Student);
if(per instanceof Student)
{
Student stu = (Student)per;
stu.fun();
}
}
}

    }

}

总结

本篇文章的内容大体上就是这些了。我们来总结一下。

对象多态性的核心在于方法的覆写
通过对象的向上转型可以实现接受参数的统一，向下转型可以实现子类扩充的调用（一般不操作向下转型，有安全隐患）
两个没有关系的类对象是不能够转型的，一定会产生ClassCastException
多态，简而言之就是同一个行为具有多个不同表现形式或形态的能力。
多态的分类：运行时多态和编译时多态。
运行时多态的前提：继承（实现），重写，向上转型与向下转型。
继承链中对象方法的调用的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。