java - 如何在 this(...) 或 super(...) 之前编写 "insert"代码？

Question

有没有办法在调用 super(...) 或 this(...) 构造函数之前实现初步计算？考虑以下示例:

public class Test {
    private final int n;
    private final int m;
    private final int[] store;

    public Test(int n, int m) {
        /* This is common (most generic) constructor of the class Test.
         It is desirable to invoke it via this(...) call
         from any other constructor of this class
         since it contains some common initialization tasks,
         which are better to concentrate in one place instead
         of scattering them throught the class, due to
         maintainability and security reasons. */
        this.n = n;
        this.m = m;
        store = new int[n];
        // ...
    }

    public Test(Object data) {
        /* This is specific constructor. It depends on some parameters
         which must be processed prior to a call of the Test(int n, int m)
         constructor to get its arguments. The problem is, this processing
         cannot appear here because a call to this(...) must be the first
         statement in a constructor. */
        int a; // Must be calculated via lengthy code
        int b; // Must be calculated via lengthy code
        this(a, b); // <- Compiler error here
        // ... further initialization
    }
}

如何实现参数计算？最简单的解决方案是用静态方法替换特定的构造函数。但是，如果它必须是一个构造函数而没有其他内容(例如，它有可能在后代类中使用)，该怎么办？到目前为止我找到的最好的解决方案是引入一个包含公共(public)构造函数所有参数的静态内部类，并用它来存储特定构造函数开头的参数:

public class Test {
    private final int n;
    private final int m;
    private final int[] store;

    protected static class ConstrParams {
        int nParam;
        int mParam;

        ConstrParams(int n, int m) {
            nParam = n;
            mParam = m;
        }
    }

    protected Test(ConstrParams params) {
        /* This is the common constructor now.
         It is marked as protected because it is essentially auxiliary,
         as well as the class ConstrParams is. */
        n = params.nParam;
        m = params.mParam;
        store = new int[n];
        // ...
    }

    public Test(int n, int m) {
        // This is public interface to the common constructor.
        this(new ConstrParams(n, m));
    }

    private static ConstrParams makeParams(Object data) {
        /* This is a procedure that inserts lengthy calculations
         before constructor chain invocation. */
        int a = 0; // Calculate a from data
        int b = 0; // Calculate b from data
        return new ConstrParams(a, b);
    }

    public Test(Object data) {
        // Specific constructor. Now compiles successfully.
        this(makeParams(data));
        // ... further initialization
    }
}

有没有更好的解决办法？当 Test(Object data) 必须调用某个 super(...) 构造函数而不是 this(...) 时，情况更糟因为在这种情况下我们的灵 active 较差，并且通常无法更改祖先类的代码。

Answer 1

这是我发现的一种通用方法。它允许在调用 this(...) 或 super(...) 之前注入(inject)任何代码，从而克服 Java 对 this(. ..) 或 super(...) 作为构造函数中的第一个语句。

public class Test {
    private final int n;
    private final int m;
    private final int[] store;

    public Test(int n, int m) {
        // Primary constructor is unchanged
        this.n = n;
        this.m = m;
        store = new int[n];
        // ...
    }

    private static class ConstrParams {
        private int nParam;
        private int mParam;
        /* This class can also be used by more than one constructor
         or independently, to calculate the parameters and store
         them for other purposes. */
        private ConstrParams(Object data) {
            /* Calculate the parameters and/or do any other operations
             (preprocessing) that you would do in the specific constructor prior
             to calling another constructor. You may even add as many auxiliary
             methods as needed into this class and use them in this constructor. */
            nParam = 1;
            mParam = 2;
        }
    }

    /* Intermediate constructor, the main purpose of which is to extract
     parameters (if any) from a ConstrParams object and pass them to a primary
     or an inherited constructor. If ConstrParams produces no parameters but
     makes some pre-this() or -super() actions, this constructor makes
     insertion of such actions available. */
    private Test(ConstrParams params) {
        this(params.nParam, params.mParam);
        /* You can also call super(...) instead of this(...).
         When calling super(...), primary constructor may even not exist. */
//        super(params.nParam, params.mParam);
        /* As the reference to ConstrParams vanishes upon return to the
         calling constructor, you may want to make some actions connected
         with the params object (post-processing) or store the reference to it
         into this object. If so, here's the right place to do it. Otherwise,
         no further action is generally needed in this constructor. */
    }

    public Test(Object data) {
        // Specific constructor. Now compiles successfully.
        this(new ConstrParams(data));
        // ... further initialization
    }
}

优点包括:

• 被调用的构造函数的代码不受影响。这在使用 super(...) 时特别有用，因为对祖先类的更改通常是不受欢迎或不可能的。使用 this(...) 时，上述方法不会影响任何依赖主构造函数的代码。
• 它不依赖于被调用的构造函数需要的参数数量。只需将任意数量的它们添加为 ConstrParams 类的字段，然后在调用主构造函数或继承构造函数之前提取即可。如果参数是联合计算的(即，将它们的计算分成两个或多个独立的方法是不可能或昂贵的)，则此方法允许这样做。可能(而且经常)有这样的情况:被调用的构造函数不带任何参数，而您只需要在 this(...) 或 之前在依赖构造函数中执行一些操作即可super(...) 调用(此类操作的一个示例是日志记录)。此解决方案允许您执行此类操作。
• 生成参数和/或产生副作用的辅助ConstrParams类可用于其他目的。如果主类的多个辅助构造函数需要克服 this(...)/super(...) 调用限制，您可以在其中引入更多构造函数。
• 统一应用于 this(...) 和 super(...) 调用。