_{这是针对类似问题的规范问答，其中问题是隐藏的结果。}

我在我的类中定义了两个字段，一个是引用类型，一个是原始类型。在类的构造函数中，我尝试将它们初始化为一些自定义值。

当我稍后查询这些字段的值时，它们会返回 Java 的默认值，引用类型为 null，原始类型为 0。为什么会这样？

这是一个可重现的例子:

public class Sample {
    public static void main(String[] args) throws Exception {
        StringArray array = new StringArray();
        System.out.println(array.getCapacity()); // prints 0
        System.out.println(array.getElements()); // prints null
    }
}

class StringArray {
    private String[] elements;
    private int capacity;
    public StringArray() {
        int capacity = 10;
        String[] elements;
        elements = new String[capacity];
    }
    public int getCapacity() {
        return capacity;
    }
    public String[] getElements() {
        return elements;
    }
}

我希望 getCapacity() 返回值 10，而 getElements() 返回一个正确初始化的数组实例。

最佳答案

Java 程序中定义的实体(包、类型、方法、变量等)有names .这些用于在程序的其他部分引用这些实体。

Java 语言定义了一个scope对于每个名字

The scope of a declaration is the region of the program within which the entity declared by the declaration can be referred to using a simple name, provided it is visible (§6.4.1).

换句话说，作用域是一个编译时概念，它决定了一个名字可以用来指代某个程序实体的位置。

您发布的程序有多个声明。让我们从

private String[] elements;
private int capacity;

这些是 field声明，也称为 instance variables ， IE。在 class body 中声明的一种成员. Java 语言规范声明

The scope of a declaration of a member m declared in or inherited by a class type C (§8.1.6) is the entire body of C, including any nested type declarations.

这意味着您可以在 StringArray 的主体中使用名称 elements 和 capacity 来引用这些字段。

构造函数主体中的前两个语句

public StringArray() {
    int capacity = 10;
    String[] elements;
    elements = new String[capacity];
}

实际上是local variable declaration statements

A local variable declaration statement declares one or more local variable names.

这两个语句在您的程序中引入了两个新名称。碰巧这些名称与您的字段相同。在您的示例中，capacity 的局部变量声明还包含一个初始化程序，它初始化该局部变量，而不是同名字段。您名为 capacity 的字段已初始化为 default value对于它的类型，即。值 0。

elements 的情况有点不同。局部变量声明语句引入了一个新名称，但是assignment expression呢？ ？

elements = new String[capacity];

elements 指的是什么实体？

范围状态的规则

The scope of a local variable declaration in a block (§14.4) is the rest of the block in which the declaration appears, starting with its own initializer and including any further declarators to the right in the local variable declaration statement.

在这种情况下， block 是构造函数体。但是构造函数主体是 StringArray 主体的一部分，这意味着字段名称也在范围内。那么 Java 如何确定您指的是什么？

Java引入了Shadowing的概念消除歧义。

Some declarations may be shadowed in part of their scope by another declaration of the same name, in which case a simple name cannot be used to refer to the declared entity.

(简单名称是单个标识符，例如。elements。)

文档还指出

A declaration d of a local variable or exception parameter named n shadows, throughout the scope of d, (a) the declarations of any other fields named n that are in scope at the point where d occurs, and (b) the declarations of any other variables named n that are in scope at the point where d occurs but are not declared in the innermost class in which d is declared.

这意味着名为 elements 的局部变量优先于名为 elements 的字段。表达式

elements = new String[capacity];

因此正在初始化局部变量，而不是字段。该字段被初始化为 default value对于它的类型，即。值 null。

在您的方法 getCapacity 和 getElements 中，您在它们各自的 return 语句中使用的名称指的是字段，因为它们的声明是程序中那个特定点的唯一范围内的。由于字段被初始化为 0 和 null，因此这些是返回的值。

解决方案是完全摆脱局部变量声明，从而让名称引用实例变量，正如您最初想要的那样。例如

public StringArray() {
    capacity = 10;
    elements = new String[capacity];
}

带构造函数参数的阴影

类似于上述情况，您可能有formal (constructor or method) parameters隐藏具有相同名称的字段。例如

public StringArray(int capacity) {
    capacity = 10; 
}

阴影规则状态

A declaration d of a field or formal parameter named n shadows, throughout the scope of d, the declarations of any other variables named n that are in scope at the point where d occurs.

在上面的示例中，构造函数参数capacity 的声明隐藏了同样名为capacity 的实例变量的声明。因此不可能用简单的名称来引用实例变量。在这种情况下，我们需要用它的 qualified name 来引用它。 .

A qualified name consists of a name, a "." token, and an identifier.

在这种情况下，我们可以使用 primary expression this作为 field access expression 的一部分引用实例变量。例如

public StringArray(int capacity) {
    this.capacity = 10; // to initialize the field with the value 10
    // or
    this.capacity = capacity; // to initialize the field with the value of the constructor argument
}

每个 kind of variable 都有阴影规则、方法和类型。

我的建议是尽可能使用唯一的名称，从而完全避免这种行为。

关于java - 当我在类的构造函数中声明并初始化字段时，为什么我的字段被初始化为 null 或默认值零？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42117386/