多态在Java中的提现思想
我们都知道在java中，面向对象有三大特征，封装，继承，和多态。封装隐藏实现细节，对外提供享用的访问方式，而且提高了代码的复用性。在事物对象有相同的属性和共同的内容的时候，我们可以把相同的内容的抽取出来，然后不同的事物类别去继承这些共同的属性。继承虽然打破了代码的封装，但是同样起到复用代码的好处。那我们再看看多态在java中是怎么体现的。
首先，我们来看一段代码，包括其中的备注和分析：
//描述狗,狗有吃饭，看家的行为 class Dog { public void eat() { System.out.println("啃骨头"); } public void lookHome() { System.out.println("看家"); } } //描述猫，猫有吃饭，抓老鼠行为 class Cat { public void eat() { System.out.println("吃鱼"); } public void catchMouse() { System.out.println("抓老鼠"); } } Class Demo { public static void main(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 class Animal { abstract public void eat(); }
由于每一种动物的eat方式都不一样，因此在父类中无法准确描述eat的具体行为，所以只能使用抽象的方法进行描述，而这个类也为抽象类别。然后把Dog和Cat这个类继承Animal这个父类如下：
//描述狗,狗有吃饭，看家的行为 class Dog extends Animal { public void eat() { System.out.println("啃骨头"); } public void lookHome() { System.out.println("看家"); } } //描述猫，猫有吃饭，抓老鼠行为 //////.......................................................................................... class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } public void catchMouse() { System.out.println("抓老鼠"); } }
其次，我们可以分析，Dog和Cat都属于Animal的一种，那么我们是否可以引用Animal创建具体的对象呢？
Animal d = new Dog();
Animal c = new Cat();
在上述代码基础之上，当再让动物去做事时，不用面对具体的动物，而只要面对Animal即可。因此method方法可以修改为：
public static void method(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 成员变量
我们看如下代码：
class Fu { int num = 4; } class Zi extends Fu { int num = 5; } class Demo { public static void main(String[] args) { Fu d = new Zi(); System.out.println(d.num); Zi z = new Zi(); System.out.println(z.num); } }
运行看结果如下：
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
l 成员方法
如果是调用成员方法呢？看如下代码：
lass Fu { int num = 4; void show() { System.out.println("Fu show num"); } } class Zi extends Fu { int num = 5; void show() { System.out.println("Zi show num"); } } class Demo { public static void main(String[] args) { Fu f = new Zi(); f.show(); } }
运行结果如下：
多态成员函数
编译时期：参考引用变量所属的类，如果没有类中没有调用的函数，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员函数。
l 静态方法
如果，是类中的被静态修饰的方法呢？
class Fu { int num = 4; static void method() { System.out.println("fu static method run"); } } class Zi extends Fu { int num = 5; static void method() { System.out.println("zi static method run"); } } class Demo { public static void main(String[] args) { Fu f = new Zi(); f.method(); } }
运行结果如下：
多态静态函数
多态调用时：编译和运行都参考引用类型变量所属的类中的静态函数。
简而言之：编译和运行看等号的左边。其实真正调用静态方法是不需要对象的，静态方法通过类直接调用。
总结，在多态中，对于成员变量和静态方法，比哪一运行都看引用所属的类。
对于非静态的方法，比哪一时看引用所属的类中是否有这个方法，而运行的时候回到引用所指的对象中类中找方法
