[javase]多态 向上转型

  JNC a = new  JNC();

     对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？

     Wine a = new JNC();

     在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

     但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就望尘莫及了---1。

public class Wine {

    public void fun1(){

        System.out.println("Wine 的Fun.....");

        fun2();

    }

    public void fun2(){

        System.out.println("Wine 的Fun2...");

    }

}

public class JNC extends Wine{

    /**

     * @desc 子类重载父类方法

     *        父类中不存在该方法，向上转型后，父类是不能引用该方法的

     * @param a

     * @return void

     */

    public void fun1(String a){

        System.out.println("JNC 的 Fun1...");

        fun2();

    }

    /**

     * 子类重写父类方法

     * 指向子类的父类引用调用fun2时，必定是调用该方法

     */

    public void fun2(){

        System.out.println("JNC 的Fun2...");

    }

}

public class Test {

    public static void main(String[] args) {

        Wine a = new JNC();

        a.fun1();

    }

}-------------------------------------------------

Output:

Wine 的Fun.....

 从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

      分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。

    所以对于多态我们可以总结如下：

      指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

public class Wine {

    private String name;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Wine(){

    }

    public String drink(){

        return "喝的是 " + getName();

    }

    /**

     * 重写toString()

     */

    public String toString(){

        return null;

    }

}

public class JNC extends Wine{

    public JNC(){

        setName("JNC");

    }

    /**

     * 重写父类方法，实现多态

     */

    public String drink(){

        return "喝的是 " + getName();

    }

    /**

     * 重写toString()

     */

    public String toString(){

        return "Wine : " + getName();

    }

}

public class JGJ extends Wine{

    public JGJ(){

        setName("JGJ");

    }

    /**

     * 重写父类方法，实现多态

     */

    public String drink(){

        return "喝的是 " + getName();

    }

    /**

     * 重写toString()

     */

    public String toString(){

        return "Wine : " + getName();

    }

}

public class Test {

    public static void main(String[] args) {

        //定义父类数组

        Wine[] wines = new Wine[2];

        //定义两个子类

        JNC jnc = new JNC();

        JGJ jgj = new JGJ();

        //父类引用子类对象

        wines[0] = jnc;

        wines[1] = jgj;

        for(int i = 0 ; i < 2 ; i++){

            System.out.println(wines[i].toString() + "--" + wines[i].drink());

        }

        System.out.println("-------------------------------");

    }

}

OUTPUT:

Wine : JNC--喝的是 JNC

Wine : JGJ--喝的是 JGJ

 

  在上面的代码中JNC、JGJ继承Wine，并且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。