看完涨姿势，帮你深入了解多态 - 黑马程序员技术交流社区

<P> </P>
<DIV class=blockcode>
<BLOCKQUOTE>/*
多态：对象在不同时刻表现出来的不同状态。
原因：在设计一个方法中，通常希望具有通用性，比如实现一个动物叫，可以接受一个动物参数类型，狗叫，猫叫。
前提：
1，要有继承关系；
2，要有方法重写；//其实没有也是可以的，但是如果没有这个就没有意义。
3，要有父类引用子类对象。Fu f=new Zi;
特点：
1,成员变量：编译看左边，运行看左边。
2,构造方法：创建子类对象的时候，访问父类构造方法，对父类数据进行初始化。
3,成员方法：编译看左边，运行看右边。因为方法存在重写，所以看右边。
4,静态方法：编译看左边，运行看左边。
(静态和类相关，静态算不上重写，所以，访问还是左边的)
作用：为了提高代码的扩展性和可维护性。
格式：Fu f=new Zi();
注意事项：
多态弊端：
父类引用不能使用子类特有功能。
我就想使用子类的特有功能?行不行?
行。
怎么用呢?
1,创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
2,把父类的引用强制转换为子类的引用。(向下转型)
基本类型：隐式转换(小到大)，强制转换(大到小)。
引用类型：向上转型(小到大)，向下转型(大到小)。
对象间的转型问题：
向上转型：父类引用指向子类对象编译看左边
Fu f = new Zi();
向下转型：父类引用转为子类对象编译看子类
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
java.lang.ClassCastException:类型转换异常。
类型不匹配。
你存储的是Cat，想转换成Dog，肯定不行。
*/
class Fu
{
int a=10;
void Fu()
{
System.out.println("创建子类对象的时候，访问父类构造方法，对父类数据进行初始化?");
}
public static void show() //静态方法编译看左边，运行看左边。(静态和类相关，静态算不上重写，所以，访问还是左边的)
{
System.out.println("Fu play");
}
public void eat()
{
System.out.println("Fu eat");
}
public void speak()
{
System.out.println(a);
}
}
class Zi extends Fu
{
int a=20;//成员变量编译看左边，运行看右边。
public static void show() //静态方法编译看左边，运行看左边。(静态和类相关，静态算不上重写，所以，访问还是左边的)
{
System.out.println("Zi play");
}
public void eat() //成员方法编译看左边，运行看右边，因为存在重写
{
System.out.println("Zi eat");
}
public void speak()
{
System.out.println(a);
}
public void test()
{
System.out.println("父类能引用子类功能吗？");
}
}
class method1 //工具类，为了提高代码的扩展性和可维护性。
{
public static void method(Fu x)
{
x.show();
x.eat();
}
}
class 多态
{
public static void main(String[] args)
{
Fu f=new Zi();
f.show();
f.eat();
System.out.println(f.a);//成员变量编译看左边，运行看右边。---10
f.speak();//这个是调用子类方法，就近原则. ---20
method1.method(f);
Fu f1=new Fu();
//f1.test();//父类不能引用子类功能
Zi z=(Zi) f1;//要求该f必须是能够转换为Zi的。
//f1.test();
method1.method(f1);
/*
//多态
Animal a = new Dog(); //向上转型
a.show();
//给a重新赋值
a = new Cat(); //向上转型
a.show();
Cat c = (Cat)a; //向下转型
c.show();
c.playGame();
Dog d = (Dog)a;//java.lang.ClassCastException:类型转换异常。
d.show();
*/
}
}

复制代码