Java编程思想读书笔记（7章）

第7章 多态

　　一．再探向上转型（upcasting）

　　 将某个objectreference视为一个“referencetobasetype“的动作，称为向上转型。

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

　　 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。如果当Secondclass中的prt()函数注释掉，将输出First。

　　 2． 向上转型后只能调用baseclass中被derivedclass覆写的函数。

　　 /*
　　 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）处的函数只是Secondclass中的函数，所以不能通过n.prt(3)进行调用。

　　 二．Abstractclass和Abstractmethods

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

　　 2． abstractclass不能被实例化。

　　 3． 如果baseclass是一个abstractclass，那么derivedclass必须实现baseclass中所有的abstractmethods；否则，derivedclass也必须被声明为abstractclass。

　　 三．其它要点

　　 1． 纯粹继承与扩充

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

　　 扩充：除了覆写baseclass的函数，还实现了自己的函数
　　 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(){}//baseclass不存在的函数
　　 }
　　 2． 向下转型

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

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

　　 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();classFirst中不存在函数u()

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

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

　　 }
　　 }

关键词：Java编程思想读书笔记（7章）