Java编程思想（2nd）学习笔记（7）

第2章           多态

一．再探向上转型（upcasting）

       将某个object　reference视为一个“reference　to　base　type“的动作，称为向上转型。

1．  Upcasting后调用某个函数时，如果derived　class中覆写了该函数，则会调用derived　class中的函数；否则，会调用base　class中的函数。如

class First{

    public void prt(){

        System.out.println("First");

    }

}

class Second extends First{

       //（a）

     public void prt(){

        System.out.println("Second");

    }

}

public class ExplicitStatic{

    public static void main(String[] args){

        First n = new Second();

        n.prt();;

    }

}

结果为Second。如果当Second　class中的prt()函数注释掉，将输出First。

2．  向上转型后只能调用base　class中被derived　class覆写的函数。

/*

abstract class First{

    int i = 122;

    public void prt(){

        System.out.println("First.i = " + i);

    }

    public abstract void prt(First f);

}

 

class Second extends First{

     public void prt(){

        System.out.println("Second.i = " + i);

    }

   

    public void prt(First i)

    {

       

    }

   

    public void prt(int i)

    {

       

    }

}

public class ExplicitStatic{

    public static void main(String[] args){

        First n = new Second();

        n.prt(2);;

    }

}

*/

class First{

    public void prt(){

        System.out.println("First");

    }

}

class Second extends First{

       //（a）

     public void prt(){

        System.out.println("Second");

    }

    public void prt(int i){//（a）

        System.out.println("Second.i = " + i);

    }

}

public class ExplicitStatic{

    public static void main(String[] args){

        First n = new Second();

        n.prt(3);

    }

}

（a）处的函数只是Second　class中的函数，所以不能通过n.prt(3)进行调用。

二．Abstract　class和Abstract　methods

1．  如果一个class中存在abstract　class，则class也必须被声明为abstract　class。

2．  abstract　class不能被实例化。

3．  如果base　class是一个abstract　class，那么derived　class必须实现base　class中所有的abstract　methods；否则，derived　class也必须被声明为abstract　class。

三．其它要点

1．  纯粹继承与扩充

纯粹继承：只有base　class所建议的函数，才被derived　class加以覆写。

扩充：除了覆写base　class的函数，还实现了自己的函数

         abstract class First{

    public abstract void f();

    public abstract void g();

}

//纯粹继承

class Second extends First{

     public void f(){}

     public void g(){}

}

//扩充

class Third extends First{

     public void f(){}

     public void g(){}

     public void u(){}//base　class不存在的函数

}

2．  向下转型

1）  向下转型时只能调用base　class中被覆写过的函数

2）  只有本来就为derived　class对象时才能正确向下转弄。

class First{

     public void f(){}

     public void g(){}

}

class Second extends First{

     public void f(){}

     public void g(){}

     public void u(){}

     public void v(){}

}

public class ExplicitStatic{

    public static void main(String[] args){

        First[] x = {new First(), new Second()};

        x[0].f();

        x[1].g();

        //！x[1].u();class　First中不存在函数u()

        //((Second)x[0]).f();（a）

        ((Second)x[1]).u();

}

              }

              （a）处会抛出ClassCastException异常。