java静态变量继承_在Java中，如果子类使用实例子变量隐藏静态父变量，哪个变量将继承方法使用？...

6 个答案:

答案 0 :(得分：6)

根据Java语言规范：

如果类声明了一个具有特定名称的字段，那么该字段的声明就会隐藏在超类中具有相同名称的所有可访问的字段声明，以及该类的超接口

可以使用限定名称(如果它是静态的)来访问隐藏字段

您可以参考＆＃34; Field声明＆＃34;部分。

答案 1 :(得分：4)

他们会：

class Parent {

static String x="static in parent";

String y="instance in parent";

}

class Child extends Parent {

static String y="static in child";

String x="instance in child";

void foo() {

System.out.println("x "+x);

System.out.println("super.x " + super.x);

System.out.println("y "+y);

System.out.println("super.y " + super.y);

}

}

public class Main {

public static void main(String[] args) {

Parent parent=new Parent();

Child child=new Child();

System.out.println("Parent.x "+Parent.x);

System.out.println("parent.x "+Parent.x);

System.out.println("parent.y "+parent.y);

System.out.println("child.x "+child.x);

System.out.println("Child.y "+Child.y);

System.out.println("child.y "+child.y);

System.out.println("(Parent)child).x "+((Parent)child).x);

System.out.println("(Parent)child).y "+((Parent)child).y);

child.foo();

}

}

Parent.x static in parent

parent.x static in parent

parent.y instance in parent

child.x instance in child

Child.y static in child

child.y static in child

(Parent)child).x static in parent

(Parent)child).y instance in parent

x instance in child

super.x static in parent

y static in child

super.y instance in parent

答案 2 :(得分：4)

如果表达式名称由单个标识符组成，那么就在那里

必须是一个表示本地的可见声明

范围内的变量，参数或字段

发生标识符。否则，发生编译时错误。

如果声明声明了final字段，则名称的含义为

该字段的值。否则，表达式名称的含义

是声明声明的变量。

如果超类中的方法引用该类的特定字段(静态或其他字段)，则该字段的该字段声明将在该范围内;子类的任何字段(静态或其他)都不在范围内。因此，该方法将始终使用超类字段，即使子类继承它并且阴影该字段。

根据我对该问题的新理解，完全重写了这个答案。以下是我的第一个答案，留给后人。

字段，局部变量，方法参数的声明d，

名为n阴影的构造函数参数或异常处理程序参数

任何其他字段，局部变量，方法的声明

参数，构造函数参数或异常处理程序参数

名为n的名称​​ n在整个范围内d出现的范围内

范围d。

这表明，无论静态如何，都需要编译器隐藏父变量。

请注意，这些都与继承的方法无关，无论子类是否影响它们，它们始终使用原始变量。我怀疑这不是你要问的问题。

答案 3 :(得分：0)

请看下面的代码。如果您想从field访问ChildClass，它将使用自己的成员变量。如果您要从field访问静态SuperClass，则必须使用SuperClass.field明确调用它。可以直接访问`STATIC_FIELD``，因为编译器没有歧义。

public class SuperClass{

static String field = "staticField1";

static String STATIC_FIELD = "staticField2";

//not possible to have a member field in this class -> compile error

//String field = "memberField"; is not possible

public SuperClass() {

System.out.println( "field = " + field );

}

}

public class ChildClass extends SuperClass{

String field = "memberField";

public ChildClass() {

System.out.println( "field = " + field );//access to member field

//need to explicitly call SuperClass.field to access the static variable

System.out.println( "SuperClass.field = " + SuperClass.field );

//no need to do this when there is no amibiguity

System.out.println( "STATIC_FIELD = " + STATIC_FIELD );

}

}

另见here中的15.11.1和15.11.2以及here中的8.3

答案 4 :(得分：0)

public class Test {

public static int MYNUMBER = 5;

public Test() {

}

}

public class TestChild extends Test {

public int MYNUMBER = 8;

public TestChild() {

}

}

public class Main {

public static void main(String[] args) {

TestChild testChild = new TestChild();

// This would print out 8

System.out.println("in main test child: " + testChild.MYNUMBER);

// This won't even compile if the MYNUMBER variable is overshadowed

// If the MYNUMBER variable is not overshadowed it

// would compile and

// print out 5

// If we make MYNUMBER static also on TestChild,

// it would compile and print out 8

System.out.println("in main TestChild.MYNUMBER " + TestChild.MYNUMBER);

// This would print out 5

System.out.println(Test.MYNUMBER);

}

}

答案 5 :(得分：0)

使用Eclipse的编译器，父类中的方法仍将使用超类中的成员变量，而不是子类中的阴影变量，如下所示。这是thinksteep的答案的一个稍微修改过的版本。

class Parent {

static String x ="static in parent";

String y="instance in parent";

void bar() {

System.out.println("x "+ x);

System.out.println("y "+ y);

}

}

class Child extends Parent {

static String y ="static in child";

String x="instance in child";

void foo() {

System.out.println("x "+x);

System.out.println("super.x " + super.x);

System.out.println("y "+y);

System.out.println("super.y " + super.y);

}

}

public class Main {

public static void main(String[] args) {

Parent parent=new Parent();

Child child=new Child();

System.out.println("Parent.x "+Parent.x);

System.out.println("parent.x "+Parent.x);

System.out.println("parent.y "+parent.y);

System.out.println("child.x "+child.x);

System.out.println("Child.y "+Child.y);

System.out.println("child.y "+child.y);

System.out.println("(Parent)child).x "+((Parent)child).x);

System.out.println("(Parent)child).y "+((Parent)child).y);

System.out.println("Member variable visibility in parent:");

parent.bar();

System.out.println("Member variable visibility in child:");

child.foo();

System.out.println("Member variable visibility in inherited methods:");

child.bar();

System.exit(0);

}

/* Output:

Parent.x static in parent

parent.x static in parent

parent.y instance in parent

child.x instance in child

Child.y static in child

child.y static in child

(Parent)child).x static in parent

(Parent)child).y instance in parent

Member variable visibility in parent:

x static in parent

y instance in parent

Member variable visibility in child:

x instance in child

super.x static in parent

y static in child

super.y instance in parent

Member variable visibility in parent methods:

x static in parent

y instance in parent

*/