正在阅读：学习和使用继承时先要清楚的三点学习和使用继承时先要清楚的三点

  第一点：

  那就是

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

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

  第二点：

  那就是对“覆盖（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();

  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;

  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 {

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

  请看到的朋友评论！