子类的类成员变量能不能与其父类的类成员变量同名

Question

若类A继承了类B，则子类A的类成员变量能不能与其父类B的类成员变量同名？
如果能的话，类A与类B的类成员变量在内存里是怎么分配的，它们是否占有同一片空间，还是它们各自分配不同的内存空间？请给我详细的解释一下吧，谢谢！

Answer 1

class A {
int a = 0;
}
class B extends A {
int a = 1;
public void printParentA(){
System.out.println(super.a);
}
public void printA(){
System.out.println(this.a);
}
// run the test
public static void test(){
B testB = new B();
testB.printA();
testB.printParentA();
}
}

Answer 2

你要说明的问题我知道，不过我现在要问的是类成员变量，即STATIC变量，希望再帮我看看，最好分析一下相关的内存分配，谢谢。

Answer 3

可以用super.a=1
子类a=2 试下，我也没试过
哈哈

Answer 4

// test shade
class A {
static int staticInt = 0;
int noStaticInt = 3;

static public void staticPrint(){
System.out.println("A : static public void print()" );
}

public void print(){
System.out.println("A : public void print()" );
}
}
class B extends A {
static int staticInt = 1;
int noStaticInt = 4; static public void staticPrint(){
System.out.println("B : static public void print()" );
}

public void print(){
System.out.println("B : public void print()" );
}
public static void test(){
System.out.println("Class A.staticInt = " + A.staticInt);
System.out.println("Class B.staticInt = " + B.staticInt);
A aClass = new B();
System.out.println(aClass.staticInt);//警惕啊 类静态成员的遮蔽 和 属性成员不同
                                     // 这里会输出 0 也就是类A静态成员
 // 看似违反了多态(其实不管是类静态还是非静态属性都是没有多态的,多态是方法的)，
// 但是由于静态成员所在的这个
//类的貌似是（水平不高不敢误人）类的方法区
// 着告诉我们调用类的静态成员最好用类名而不是
// 类的实例 防止出现于逻辑不符合的

System.out.println(aClass.noStaticInt);//输出3 也就是A类的 但明明是new B类
   // 说明了遮蔽是如何绕过的，同时也说明了
   // 成员变量是无法多态的

//关于静态方法 与 非静态方法的 多态是有区别的 你试试就会明白
aClass.staticPrint();//这儿会输出什么呢，哈哈 是A : static public void print()
               // 发现没有没有多态的效果 ，如果是Override（覆盖）则会输出
               // B类的B : static public void print()毕竟是 new B（）

aClass.print();//是B : public void print() 这就典型的多态性Override（覆盖）了 

//这仅仅是个启示, 要想掌握 重载（OverLoad） 重写覆盖（Override） 遮蔽（shade/shadow）
//遮掩（obscure）隐藏（hide）可以看看 Java Pullzer 里的 下面是片段

名字重用的术语表 
覆写（override）
一个实例方法可以覆写（override）在其超类中可访问到的具有相同签名的所有实例方法
[JLS 8.4.8.1]，从而使能了动态分派（dynamic dispatch）；换句话说，VM将基于实例的运行期类型来选
择要调用的覆写方法[JLS 15.12.4.4]。覆写是面向对象编程技术的基础，并且是唯一没有被普遍劝阻的名字
重用形式： 
class Base {
     public void f() { }
} class Derived extends Base {
     public void f() { } // overrides Base.f()
}
隐藏（hide）
一个域、静态方法或成员类型可以分别隐藏（hide）在其超类中可访问到的具有相同名字
（对方法而言就是相同的方法签名）的所有域、静态方法或成员类型。隐藏一个成员将阻止其被继承[JLS 
8.3, 8.4.8.2, 8.5]： 
class Base {
     public static void f() { }
} class Derived extends Base {
     private static void f() { } // hides Base.f()
}
重载（overload） 
在某个类中的方法可以重载（overload）另一个方法，只要它们具有相同的名字和不同的
签名。由调用所指定的重载方法是在编译期选定的[JLS 8.4.9, 15.12.2]： 
class CircuitBreaker {
     public void f(int i)     { } // int overloading
     public void f(String s) { } // String overloading
}
遮蔽（shadow）
一个变量、方法或类型可以分别遮蔽（shadow）在一个闭合的文本范围内的具有相同名字
的所有变量、方法或类型。如果一个实体被遮蔽了，那么你用它的简单名是无法引用到它的；根据实体的不同，
有时你根本就无法引用到它[JLS 6.3.1]： 
class WhoKnows {
     static String sentence = "I don't know.";
     public static woid main(String[ ] args) {
          String sentence = “I know!”;   // shadows static field
          System.out.println(sentence);  // prints local variable
     }
}
尽管遮蔽通常是被劝阻的，但是有一种通用的惯用法确实涉及遮蔽。构造器经常将来自其
所在类的某个域名重用为一个参数，以传递这个命名域的值。这种惯用法并不是没有风险，但是大多数Java程序员都认为这种风格带来的实惠要超过其风险： 
class Belt {
     private final int size;
     public Belt(int size) { // Parameter shadows Belt.size
          this.size = size;
     }
}
遮掩（obscure）
一个变量可以遮掩具有相同名字的一个类型，只要它们都在同一个范围内：如果这个名字
被用于变量与类型都被许可的范围，那么它将引用到变量上。相似地，一个变量或一个类型可以遮掩一个包。遮
掩是唯一一种两个名字位于不同的名字空间的名字重用形式，这些名字空间包括：变量、包、方法或类型。如果一个类型或一个包被遮掩了，那么你不能通过其简单名引用到它，除非是在这样一个上下文环境中，即语法只允
许在其名字空间中出现一种名字。遵守命名习惯就可以极大地消除产生遮掩的可能性[JLS 6.3.2, 6.5]： 
public class Obscure {
     static String System;  // Obscures type java.lang.System
     public static void main(String[ ] args) {
          // Next line won't compile: System refers to static field
          System.out.println(“hello, obscure world!”);
     }
}
}

Answer 5

不占同一内存空间，static变量跟class有关系，跟class实例没关系。详细楼主可参考<<深入java虚拟机>>