第一点：

那就是

         1.如果子类覆盖了父类的方法，那么子类对象调用该方法时，被该方法修改的类级别变量是子类的变量。
         2.如果子类没有覆盖父类方法，而直接调用父类的方法，那么被该方法修改的类级别变量是父类的变量。

1则如下例：

public   class  Temp {
   public   static   void  main(String args[]) {
    b bb  =   new  b();
    bb.fuqin();
  }
}
class  a {
   public  String s  =   " fuqin " ;
   public   void  fuqin() {
    System.out.println(s);
  }
}
class  b  extends  a {
   public  String s  =   " erzi " ;
   public   void  fuqin() {
    System.out.println(s);
  }
}
// 结果为erzi

2.则如下例：

public   class  Temp {
   public   static   void  main(String args[]) {
    b bb  =   new  b();
    bb.fuqin();
  }
}
class  a {
   public  String s  =   " fuqin " ;
   public   void  fuqin() {
    System.out.println(s);
  }
}
class  b  extends  a {
   public  String s  =   " erzi " ;
   public   void  erzi() {
    System.out.println(s);
  }
}
// 结果为fuqin

第二点：

那就是对“覆盖（override）”和“重载（overload）”以及重建的概念的清晰。
先声明一下：重建就是写一个新的方法。
如下例：
下面这个叫覆盖

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Sub sub  =   new  Sub();
    sub.plus( 2 );
    System.out.println(sub.i);
  }
}

class  Super  {
   protected   int  i;
   void  plus( int  i)  {
     this .i  +=  i;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i) {
     this .i = i + 5 ;
  }
}

下面这个叫重建，不是重载：

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Sub sub  =   new  Sub();
    sub.plus( 2 );
    sub.plus( 2 , 2 );
    System.out.println(sub.i);
    System.out.println(((Super)sub).i);
  }
}

class  Super  {
   protected   int  i;
   void  plus( int  i)  {
     this .i  +=  i;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i, int  j) {
     this .i = i + j;
  }
   void  jian( int  i) {
     this .i = this .i - i;
  }
}

第三点：

那就是通常所说的“继承后使用多态”、“动态方法调度”、“运行时类型识别”了。先不要被上面的术语搞昏头哦:-)
可以总结为以下两条：
1.默认状态(和强制类型转换状态相区别)下，该对象(sub)能且只能调用父类方法和父类变量(调用子类方法时会出现编译期错误)。此种情况下，还有两种不同的情况：
           ▲被调用方法是被子类覆盖的方法，这时父类变量不能被该方法修改。【注1】
           ▲被调用方法没有被子类覆盖，这时父类变量可以被该方法修改。
看看下面的代码，注意1～5处。

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Super sub  =   new  Sub();
    System.out.println(sub.i); // 打印结果为0----------------------------------------------1
    sub.plus( 3 ); // 默认状态下调用被覆盖了的父类方法------------------------------2
    System.out.println(sub.i); // 打印结果为0----------------------------------------------3
    sub.print(); // 默认状态下调用没有被覆盖的父类方法----------------------------4
    System.out.println(sub.i); // 打印结果为5：-------------------------------------------5
  }
}

class  Super  {
   protected   int  i = 0 ;
   void  plus( int  i)  {
     this .i  = 3 ;
  }
   void  print() {
     this .i = 5 ;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i)  {
     this .i  =  i  +   8 ;
  }

   void  plus( int  i,  int  j)  {
     this .i  =  i  +  j;
  }

   void  reduce( int  i)  {
     this .i  =   this .i  -  i;
  }
}

2.强制类型转换状态下【注2】，该对象(sub)能且只能调用其子类方法和子类变量(这时被修改的就是子类变量 了)。
        此种情况下，也有两种不同情况：
                ▲调用方法时强制转换，比如下面的((Sub)sub).plus(int i);
                ▲调用变量时强制转化，比如下面的System.out.println(((Sub)sub).i);
        看看下面的代码，注意6、7处：

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Super sub  =   new  Sub();
    ((Sub)sub).plus( 3 ); // 调用方法时强制转换----------------------------------------------6
    System.out.println(((Sub)sub).i); // 调用变量时的强制转换，打印结果11------7
  }
}

class  Super  {
   protected   int  i = 0 ;
   void  plus( int  i)  {
     this .i  = 3 ;
  }
   void  print() {
     this .i = 5 ;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i)  {
     this .i  =  i  +   8 ;
  }

   void  plus( int  i,  int  j)  {
     this .i  =  i  +  j;
  }

   void  reduce( int  i)  {
     this .i  =   this .i  -  i;
  }
}

【注1】这种情况下，把该对象强制转换为子类对象时，可以发现，如果子类中覆盖了父类的方法，那么子类的变量 被改变了。如下例中。
【注2】对父类强制转换的结果和默认状态下是相同的，所以，这里只讨论对子类强制转换。

       下面的两个例子混合了上述情况，体验一下，注意8～17处。
例1.

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Super sub  =   new  Sub();
    sub.plus( 3 ); // 默认状态下调用被覆盖了的父类方法---------------------------------8
    System.out.println(sub.i); // 调用变量时强制转化，打印结果为0-----------------9
    System.out.println(((Sub)sub).i); // 打印结果为11--------------------------------------10
  }
}

class  Super  {
   protected   int  i = 0 ;
   void  plus( int  i)  {
     this .i  = 3 ;
  }
   void  print() {
     this .i = 5 ;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i)  {
     this .i  =  i  +   8 ;
  }

   void  plus( int  i,  int  j)  {
     this .i  =  i  +  j;
  }

   void  reduce( int  i)  {
     this .i  =   this .i  -  i;
  }
}

例2.

public   class  Temp  {
   public   static   void  main(String[] args)  {
    Super sub  =   new  Sub();
    ((Sub)sub).plus( 3 ); // 强制转换状态下调用子类方法(不管其有无覆盖其父类方法)--11
    System.out.println(((Sub)sub).i); // 调用变量时的强制转换,打印结果为11---------------12
    ((Sub)sub).plus( 2 , 2 ); // -----------------------------------------------------------------------------------13
    System.out.println(((Sub)sub).i); // 打印结果为4--------------------------------------------------14
    System.out.println(sub.i); // 打印结果为0-----------------------------------------------------------15
    sub.print(); // 默认状态下调用没有被子类覆盖的父类方法----------------------------------16
    System.out.println(sub.i); // 打印结果为5-----------------------------------------------------------17
  }
}

class  Super  {
   protected   int  i = 0 ;
   void  plus( int  i)  {
     this .i  = 3 ;
  }
   void  print() {
     this .i = 5 ;
  }
}

class  Sub
     extends  Super  {
   protected   int  i  =   1 ;
   void  plus( int  i)  {
     this .i  =  i  +   8 ;
  }

   void  plus( int  i,  int  j)  {
     this .i  =  i  +  j;
  }

   void  reduce( int  i)  {
     this .i  =   this .i  -  i;
  }
}