1. class Super{
   
2.         int i=0;
   
3.         public Super(String a){
   
4.                 System.out.println("A");
   
5.                 i=1;        
   
6.         }
   
7.         public Super(){
   
8.                 System.out.println("B");
   
9.         }
   
10. }
    
11. 
    
12. class Demo extends Super{
    
13.         int i=10;
    
14.         public Demo(String a){
    
15.                 super();
    
16.                 i=5;
    
17.                 System.out.println("C");
    
18.                                                 
    
19.         }
    
20. 
    
21. }
    
22. class Test{
    
23. 
    
24.         public static void main(String[] args){
    
25.                 int i=4;
    
26.                 Super d = new Demo("A");
    
27.                 System.out.println(d.i);
    
28.                 System.out.println(i);
    
29.   }
    
30. }

复制代码

上面代码输出结果为 B C 0 4
多态的前提
                A：类与类(或接口)要有继承(或实现)关系。
                B：一定要有方法的重写。
                C：一定要有父类或者接口的引用指向子类的对象
上面的代码没有方法从写，只有成员变量的名一样，但是还是形成多态，Why ?

老毕说的很清楚的   

class Super{
        int i=0;
        public Super(String a){
                System.out.println("A");
                i=1;        
        }
        public Super(){
                System.out.println("B");
        }
}
class Demo extends Super{
        int i=10;
        public Demo(String a){
                super();
                i=5;
                System.out.println("C");
                                                
        }
}
class Test{
        public static void main(String[] args){
                int i=4;
                Super d = new Demo("A");          //这里，父类对象用子类来实例化。多态主要是对非静态方法实现动态绑定，这里使用的是子类的构造方法
                                                                    //Demo的构造方法第一句是super，然后进入父类的无参构造，输出B，然后回来，i=5，输出C
                System.out.println(d.i);               //父类对象调用父类成员，所以d.i输出是0。。。。。也用到了多态，编译的时候，首先去看父类是否存在i，不存在编译就报错
                System.out.println(i);                 //这里输出局部变量i=4；
  }
}

Super d=new Demo("A");定义了一个父类类型的引用指向一个子类的对象，这个本身就是多态的向上转型特性。

当调用子类构造函数构建子类对象的时候，必然会先调用父类的构造函数，即先构建一个父类对像，因此父类的成员(变量和方法)也会被构建。 如果子类中存在同名，内存中将会同时存在父类的同名成员和子类的同名成员。
Java的多态性只针对方法来说的，成员变量不存在多态，因此成员变量只与访问的变量类型有关，而方法的调用遵从多态的规则，在多态中，成员变量的特点是，无论是编译还是运行，都参考引用变量所属的类，所以在执行到   System.out.println（d.i）;   这一句时是父类直接调用自己的成员变量（子类虽有同名成员变量，但成员变量不存在覆盖，也不存在多态）。
多说一句，本例的运行结果更准确的说应该是：B
                                                                            C
                                                                            0
                                                                            4
:D:D

1. class Super{
   
2.         int i=0;
   
3.         public Super(String a){
   
4.                 System.out.println("A");
   
5.                 i=1;        
   
6.         }
   
7.         public Super(){
   
8.                 System.out.println("B");
   
9.         }
   
10. }
    
11. 
    
12. class Demo extends Super{
    
13.         int i=10;
    
14.         public Demo(String a){
    
15.                 super();
    
16.                 i=5;
    
17.                 System.out.println("C");
    
18.                                                 
    
19.         }
    
20. 
    
21. }
    
22. class Test{
    
23. 
    
24.         public static void main(String[] args){
    
25.                 int i=4;
    
26.                 Super d = new Demo("A");//这里就的多态。父类的引用指向子类的对象。
    
27.                 System.out.println(d.i);// 多态的特性之一，成员变量显示的是父类的。
    
28.                 System.out.println(i);//局部变量在局部有效。
    
29.   }
    
30. }

复制代码

class Super {
int i = 0;
public Super(String a) {
  System.out.println("A");
  i = 1;
}
public Super() {
  System.out.println("B");
}
}
class Demo extends Super {
int i = 10;
public Demo(String a) {
  super();
  i = 5;
  System.out.println("C");
}
}
class Test {
public static void main(String[] args) {
  int i = 4;
  /*
   * 在实例化Demo类对象时调用了Demo类中的Demo(String a)这个构造函数
   * 而这个构造函数又通过super()调用了父类的构造函数，所以第一步输出"B"
   * 然后调用Demo类Demo(String a)这个构造函数函数中的打印方法输出"C"
   */
  Super d = new Demo("A");
  
  /*
   * 多态中成员变量的特点是无论编译和运行都参考左边，即引用型变量所属的类。
   * 由于d当前是属于Super的，所以d.i的值为super类中的int i = 0;
   * 所以这步输出的结果为"0"
   */
  System.out.println(d.i);
  
  /*
   * 这个i打印的是main函数的局部变量int i = 4;
   * 所以这步输出的结果为"4"
   */
  System.out.println(i);
}
}

在整个实现中只用到了一个多态的特性,即向上转型.也就是这句代码Super d = new Demo("A");
其它代码都没有用到多态的特性.

class Super {
int i = 0;
public Super(String a) {
  System.out.println("A");
  i = 1;
}
public Super() {
  System.out.println("B");
}
}
class Demo extends Super {
int i = 10;
public Demo(String a) {
  super();
  i = 5;
  System.out.println("C");
}
}
class Test {
public static void main(String[] args) {
  int i = 4;
  /*
   * 在实例化Demo类对象时调用了Demo类中的Demo(String a)这个构造函数
   * 而这个构造函数又通过super()调用了父类的构造函数，所以第一步输出"B"
   * 然后调用Demo类Demo(String a)这个构造函数函数中的打印方法输出"C"
   */
  Super d = new Demo("A");
  
  /*
   * 多态中成员变量的特点是无论编译和运行都参考左边，即引用型变量所属的类。
   * 由于d当前是属于Super的，所以d.i的值为super类中的int i = 0;
   * 所以这步输出的结果为"0"
   */
  System.out.println(d.i);
  
  /*
   * 这个i打印的是main函数的局部变量int i = 4;
   * 所以这步输出的结果为"4"
   */
  System.out.println(i);
}
}

在整个实现中只用到了多态的一个特性,即向上转型.也就是Super d = new Demo("A");这句代码.
其它代码都没有使用到多态的特性.