[摘要]第7章 多态 一．再探向上转型（upcasting） 将某个objectreference视为一个“referencetobasetype“的动作，称为向上转型。 1． Upcasting后调用某个函数时，如果derivedclass中覆写了该函数，则会调用derivedclass中的函...
第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();
}
}
……