学习和使用继承时先要清楚的三点

  第一点：

  那就是

         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;
    }
  }

  请看到的朋友评论！