将构造函数方法拆分为多个部分 - 最终值的问题

Question

我想将类的构造函数分成几个部分。但我有一个问题...

是否可以在构造函数内部调用的方法中初始化最终值？必须直接在构造函数中初始化吗？

这...

import java.util.Scanner;

public final class A
{
    private final int L;
    private final int D;
    private final int N;

    public A()
    {
        Scanner scanner = new Scanner(System.in);
        this.getFirstLine(scanner);

        /* the rest of the constructor method */
    }

    private void getFirstLine(Scanner scanner)
    {
        this.L = scanner.nextInt();
        this.D = scanner.nextInt();
        this.N = scanner.nextInt();
    }
}

给了我类似于无法分配最终字段 AL 的错误。

那么它被视为一个作业吗？是的？

有没有一种方法可以拆分构造函数来实现我想要的？

提前致谢。

Answer 1

这个怎么样。

import java.util.Scanner;

public final class A {

    private final int l;
    private final int d;
    private final int n;

    public A() {
        Scanner scanner = new Scanner(System.in);
        int[] list = this.getFirstLine(scanner);
        l = list[0];
        d = list[1];
        n = list[2];

        /* the rest of the constructor method */
    }

    private int[] getFirstLine(Scanner scanner) {
        return new int[]{scanner.nextInt(), scanner.nextInt(), scanner.nextInt()};
    }
}

Answer 2

您不能根据 Java 语言规范< /a>:

必须在声明它的类的每个构造函数（第 8.8 节）的末尾明确分配一个空白的最终实例变量（第 16.9 节）；否则会出现编译时错误。

您可以在构造函数中执行此操作，因为编译器可以保证每个实例仅调用构造函数一次。下面的代码可以编译。我刚刚验证了它：

import java.util.Scanner;

public final class A
{
    private final int L;
    private final int D;
    private final int N;

    public A()
    {
        Scanner scanner = new Scanner(System.in);
        this.L = scanner.nextInt();
        this.D = scanner.nextInt();
        this.N = scanner.nextInt();

        /* the rest of the constructor method */
    }
}

您不能在非构造函数方法中分配最终变量，因为不能保证每个实例仅调用一次。

Answer 3

是否可以在构造函数内部调用的方法中初始化最终值？

不，这是不可能的。

它必须直接在构造函数中初始化吗？

它必须在每个构造函数的末尾进行初始化。初始化可以在声明或实例初始化程序中完成......作为所有构造函数的一部分执行。

所以它被视为一个作业？是吗？

是的！

问题是该方法可以在任何时候调用：

• 它可以被构造函数调用两次，
• 可以在构造对象之后调用，或者
• 可以在赋值之前/之后抛出异常，不清楚分配是否发生。 （构造函数可以捕获异常...）

JLS 不要求编译器进行复杂的分析以确保赋值在构造期间（而不是构造之后）发生一次且仅发生一次，而是简单地禁止在该上下文中进行赋值。

有没有办法拆分构造函数来实现我想要的？

您可以在单独的方法中计算值，但final的实际初始化必须在构造函数、声明初始值设定项或初始值设定项块中执行。

（如果框架中有子类，则可能会使用其他技巧。）

Answer 4

最终成员只能在实例初始化期间设置。因此，您可以在声明时、在初始化块或构造函数中初始化 Final 字段。为什么不将 getFirstLine 设为私有构造函数：

private A(Scanner scanner)
{
    this.L = scanner.nextInt();
    this.D = scanner.nextInt();
    this.N = scanner.nextInt();
}

Answer 5

好的，这就是我受到答案启发后所做的：

import java.util.Scanner;

public final class A
{
    private static final Scanner scanner = new Scanner(System.in);

    private static class FirstLine
    {
        public static int[] get()
        {
            return new int[]
            {
                A.scanner.nextInt(), 
                A.scanner.nextInt(), 
                A.scanner.nextInt()
            };
        }
    }

    private final int L;
    private final int D;
    private final int N;

    public A()
    {
        int[] valuesScanned = FirstLine.get();
        this.L = valuesScanned[0];
        this.D = valuesScanned[1];
        this.N = valuesScanned[2];
    }

    /*JUST TO TEST*/
    public static void main(String[] args)
    {
        A test = new A();
        System.out.println(test.L);
        System.out.println(test.D);
        System.out.println(test.N);
    }
}

我创建了负责读取输入的私有静态类。
现在应该更符合逻辑地将其划分为单独的部分。