乱序链式构造函数

Question

public class ParentClass
{
    public ParentClass(int param);
}

public class MyClass extends ParentClass
{
    private int _a;
    private int _b;
    private int _c;

    public MyClass(String input)
    {
        _a=CalculateA(input);
        _b=CalculateB(_a);
        _c=CalculateC(_a);
        super(_b+_c);
    }

    //a expensive procedure
    private int CalculateA(String text);

    private int CalculateB(int a);
    private int CalculateC(int a);  
}

Java 不允许链式构造函数是放在构造函数中的第一个方法以外的任何东西。 链式构造函数不能将非静态方法作为参数调用（这消除了使用返回初始化值的 Initialsers 的可能性）。

如何使用合法的Java实现上述代码？

Answer 1

编辑 事实上，Java 不允许构造函数在调用父类构造函数之前进行任何计算，即使这些仅涉及静态方法（正如您的 calculateX 应该那样）和结果仅分配给类私有的变量（例如您的_a、_b 和_c）或构造函数的本地变量。

但是有一种解决方法：调用另一个构造函数，并将 calculateX 调用的结果分配给其参数 - 然后您可以在整个其他构造函数中访问此结果。

public class MyClass extends ParentClass {
    private int _a,_b,_c;

    public MyClass(String input) {
        this(calculateA(input));
    }

    private MyClass(int a) {
        this(a, calculateB(a), calculateC(a));
    }

    private MyClass(int a, int b, int c) {
        super(b + c);
        this._a = a;
        this._b = b;
        this._c = c;
    }

    private static int calculateA(String text) {
        try {Thread.sleep(1000);} catch (Exception e) {}  // expensive ;-)
        return text.length();
    }

    private static int calculateB(int a) { /* ... */ }
    private static int calculateC(int a) { /* ... */ }
}

编辑 2 由于需要存储更多计算或更多中间结果以供以后使用，这种方法将导致构造函数链更长，仅包含 this(...)-调用。一个更奇特的解决方案，只有两个构造函数，一个是公共的，一个是私有的，可以使用辅助类（合理地是一个内部类）：

    public MyClass(String input) {
        this(new InitCalcResult(input));
    }

    private MyClass(InitCalcResult initCalcResult) {
        super(initCalcResult.initB + initCalcResult.initC);
        this._a = initCalcResult.initA;
        this._b = initCalcResult.initB;
        this._c = initCalcResult.initC;
    }

    private static class InitCalcResult {
        private int initA, initB, initC;

        InitCalcResult(String input) {
            initA = calculateA(input);
            initB = calculateB(initA);
            initC = calculateC(initA);  
        }
    }

（使用与上述相同的私有字段和静态calculateX 方法）。

Answer 2

你可以做这样的事情。

public abstract class ParentClass
{
    public ParentClass(String input){
        int a = getData(input);
        /* Do what ever u need to do with a*/
    };

    public abstract int getData(String input);
}


public class MyClass extends ParentClass
{
    private int _a;
    private int _b;
    private int _c;

    public MyClass(String input)
    {
        super(input);
    }

    public int getData(String input){
         _a=CalculateA(input);
         _b=CalculateB(_a);
         _c=CalculateC(_a);
         return _b+_c;
    }

    //a expensive procedure
    private int CalculateA(String text){/* return int */};

    private int CalculateB(int a){/* return int */};
    private int CalculateC(int a){/* return int */};  
}

由于 getData 是抽象的，因此将调用基类函数。超类将获得所需的数据。