[转]Java继承中的成员方法和变量

静态，实例变量和方法

class Super {   
  static int stat = 1;   
  int nonStat = 2;   
  static int statMethod() {   
    return 3;   
  }   
  int nonStatMethod() {   
    return 4;   
  }   
}   
public class Test extends Super {   
  static int stat = 10;   
  int nonStat = 20;   
  static int statMethod() {   
    return 30;   
  }   
  int nonStatMethod() {   
    return 40;   
  }   
  
  public static void main(String[] args) {   
    Super s = new Test();    
    //以下结果分别为： 1,2,3,40. 对于属性和静态方法来说，调用取决于声明的类型   
    System.out.println("Static is " + s.stat);   
    System.out.println("Non-Static is " + s.nonStat);   
    System.out.println("Static method is " + s.statMethod());   
    System.out.println("Non-Static method is " + s.nonStatMethod());   
  }   
}  

继承中初始化次序：
先初始化父类的静态代码--->初始化子类的静态代码-->
(创建实例时,如果不创建实例,则后面的不执行)
初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数
 

首先看一下JAVA中方法和变量在继承时的覆盖和隐藏规则

1.父类的实例变量和静态变量能被子类的同名变量隐藏
2.父类的静态方法被子类的同名静态方法隐藏
3.父类的实例方法被子类的同名实例方法覆盖

还有几点需要注意的是

1.不能用子类的静态方法隐藏 父类中同样标示（也就是返回值 名字 参数都一样）的实例方法
2.不能用子类的实例方法覆盖 父类中同样标示的静态方法
3.这点儿请注意，就是变量只会被隐藏 不会被覆盖，无论他是实例变量还是静态变量，而且，子类的静态变量可以隐藏父类的实例变量，子类的实例变量可以隐藏 父类的静态变量

总结：
1.同名的实例方法被覆盖 ，同名的静态方法被隐藏，child类的getName实例方法覆盖了parent的getName实例方法,chind的getKind方法隐藏了parent类的getKind方法
2.隐藏 和覆盖 的区别在于，子类对象转换成父类对象后，能够访问父类被隐藏 的变量和方法，而不能访问父类被覆盖 的方法
3.如果需要访问父类被隐藏 的实例变量，加上super就好了，比如访问父类的name，写上super.name就好了

 

class Parent {   
  public static String kind = "kind_parent";   
  public static int age = 30;   
  public String name = "Parent";   
  
  public static String getKind() {   
    System.out.println("static: parent.getKind()");   
    return kind;   
  }   
  public static int getAge() {   
    System.out.println("static: Parent.getAge()");   
    return age;   
  }   
  public String getName() {   
    System.out.println("nonstatic: Parent.getName()");   
    return this.name;   
  }   
}   
  
class Child extends Parent {   
  public static String kind = "kind_child";   
  public int age = 3;   
  public String name = "child";   
  
  public static String getKind() {   
    System.out.println("static: child.getkind()");   
    return kind;   
  }   
  public static String getParentKind() {   
    return Parent.kind;   
  }   
  public String getName() {   
    System.out.println("child.getName()");   
    return this.name;   
  }   
  public String getParentName() {   
    return super.name;   
  }   
}   
  
public class Test {   
  public static void main(String[] args) {   
    Child child = new Child();       
    System.out.println(child.name + "\t" + child.age + "\t" + child.kind); //child 3 kind_child   
  
    Parent parent = child;       
    System.out.println(parent.name + "\t" + parent.age + "\t" + parent.kind); //Parent 30 kind_parent       
    System.out.println(child.getParentName());  //Parent       
    System.out.println(child.getParentKind());  //kind_parent       
    child.getName(); //child.getName()       
    parent.getName(); //child.getName()       
    child.getKind(); //static: child.getkind()      
    parent.getKind();  //static: parent.getKind()   
  }   
}  

附：一个类继承了一个父类，同时实现了一个接口，打印出父类和接口中重名的变量。

abstract class Test1 {   
  int x = 1;   
}   
interface Test2 {   
  int x = 2; //default: public static final   
}   
public class Test extends Test1 implements Test2 {   
  public void print() {   
    System.out.println( ( (Test1)this).x); //or super.x   
    System.out.println( ( (Test2)this).x); //or Test2.x   
  }   
  public static void main(String[] args) {   
    Test test = new Test();   
    test.print();   
  }   
}