我们都知道在java中，面向对象有三大特征，封装，继承，和多态。封装隐藏实现细节，对外提供享用的访问方式，而且提高了代码的复用性。在事物对象有相同的属性和共同的内容的时候，我们可以把相同的内容的抽取出来，然后不同的事物类别去继承这些共同的属性。继承虽然打破了代码的封装，但是同样起到复用代码的好处。那我们再看看多态在java中是怎么体现的。
首先，我们来看一段代码，包括其中的备注和分析：
//描述狗,狗有吃饭，看家的行为
classDog
{public voideat()
{
System.out.println("啃骨头");
}public voidlookHome()
{
System.out.println("看家");
}
}//描述猫，猫有吃饭，抓老鼠行为
classCat
{public voideat()
{
System.out.println("吃鱼");
}public voidcatchMouse()
{
System.out.println("抓老鼠");
}
}
Class Demo
{public static voidmain(String[] args)
{/*有多个狗和猫对象都要调用吃饭这个行为
这样会导致d.eat();代码重复性非常严重
Dog d = new Dog();
d.eat();
为了提高代码的复用性，可以将d.eat();代码进行封装
public static void method(Dog d)
{
d.eat();
}
然后创建对象，直接调用method方法即可
method(new Dog());
但当创建Cat对象时，同样需要调用eat方法，同样可以将eat方法进行封装
public static void method(Cat c)
{
c.eat();
}*/}
}
如果当有了猪之类，创建猪这个对象，那么我们同样要封装eat的方法，每当多一种动物，都要单独定义功能，封装eat这个方法，让动物去吃，很明前代码的扩展性很差。我们分析发现不管是dog，cat还是还是如果后期出现的猪，eat是他们的共性，那么可以将eat这个动作进行抽取到父类中，如下：
abstract classAnimal
{abstract public voideat();
}
由于每一种动物的eat方式都不一样，因此在父类中无法准确描述eat的具体行为，所以只能使用抽象的方法进行描述，而这个类也为抽象类别。然后把Dog和Cat这个类继承Animal这个父类如下：
//描述狗,狗有吃饭，看家的行为
class Dog extendsAnimal
{public voideat()
{
System.out.println("啃骨头");
}public voidlookHome()
{
System.out.println("看家");
}
}//描述猫，猫有吃饭，抓老鼠行为//..........................................................................................
class Cat extendsAnimal
{public voideat()
{
System.out.println("吃鱼");
}public voidcatchMouse()
{
System.out.println("抓老鼠");
}
}
其次，我们可以分析，Dog和Cat都属于Animal的一种，那么我们是否可以引用Animal创建具体的对象呢？
Animal d = new Dog();
Animal c = new Cat();
在上述代码基础之上，当再让动物去做事时，不用面对具体的动物，而只要面对Animal即可。因此method方法可以修改为：
public static voidmethod(Animal a)
{
a.eat();
}
method(Animal a)可以接受Animal的子类型的所有小动物，而method方法不用在关心是具体的哪一个类型。即就是只建立Animal的引用就可以接收所有的Dog和Cat对象进来，让它们去eat。从而提高了程序的扩展性。其实，上述的代码已经形成多态了，Dog和Cat都是具体的动物，同时也是Animal的形态。多态顾名思义，一种事物有多种表现形态。
通过以上代码和解释，我们可以很简单的了解到多态在面向对象里面的思想。同时我们也应该清楚的认识到，用多态来描述一个事物，这个事物的前提是必须有继承的父类或者实现的接口。多态提高了程序的扩展性。然而，在上诉的例子中，Animal的引用指向Dog或者Cat的时候，只能使用父类中的方法eat，不能调用子类中特有的方法，比如Dog的lookhome()的功能。如果我们要访问子类特有的功能该怎么办呢？
当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。当要使用子类特有的功能的时候，就要使用向下转型。
比如，继续上述的例子，当Dog的类对象d调用lookhome的功能的时候，我们就需要强制转化类型。但是向下转型的时候，我们必须要做类型的判断，判断对象是否是我们要转换类型的一个实例，否则会发生ClassCastException异常转化错误。如下：
If(d instanceof Dog){
Dog d1 = (Dog)d;
}
做完判断之后，如果是，我们就把对象d向下转型为Dog的类型并且赋值给d1，这样的
就可以调用Dog类中特有的方法d1.lookhome();
多态成员的变化：
体会多态的思想之后，那么我们再来想想，如果使用多态描述事物，那么类的成员有啥变化呢？
l 成员变量
我们看如下代码：
classFu
{int num = 4;
}class Zi extendsFu
{int num = 5;
}classDemo
{public static voidmain(String[] args)
{
Fu d= newZi();
System.out.println(d.num);
Zi z= newZi();
System.out.println(z.num);
}
}
运行看结果如下：
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
l 成员方法
如果是调用成员方法呢？看如下代码：
lass Fu
{int num = 4;voidshow()
{
System.out.println("Fu show num");
}
}class Zi extendsFu
{int num = 5;voidshow()
{
System.out.println("Zi show num");
}
}classDemo
{public static voidmain(String[] args)
{
Fu f= newZi();
f.show();
}
}
运行结果如下：
多态成员函数
编译时期：参考引用变量所属的类，如果没有类中没有调用的函数，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员函数。
l 静态方法
如果，是类中的被静态修饰的方法呢？
classFu
{int num = 4;static voidmethod()
{
System.out.println("fu static method run");
}
}class Zi extendsFu
{int num = 5;static voidmethod()
{
System.out.println("zi static method run");
}
}classDemo
{public static voidmain(String[] args)
{
Fu f= newZi();
f.method();
}
}
运行结果如下：
多态静态函数
多态调用时：编译和运行都参考引用类型变量所属的类中的静态函数。
简而言之：编译和运行看等号的左边。其实真正调用静态方法是不需要对象的，静态方法通过类直接调用。
总结，在多态中，对于成员变量和静态方法，比哪一运行都看引用所属的类。
对于非静态的方法，比哪一时看引用所属的类中是否有这个方法，而运行的时候回到引用所指的对象中类中找方法
2955
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
