从构造函数调用可重写方法
简而言之，这是错误的，因为它不必要地打开了许多错误的可能性。当@Override被调用时，该对象的状态可以是不一致的和/或不完整。

引用有效Java 2nd Edition，条款17：继承的设计和文档，或者禁止这样做：

类必须遵守一些其他限制以允许继承。构造函数不得直接或间接调用可重写的方法。如果违反此规则，将导致程序失败。超类构造函数在子类构造函数之前运行，因此子类中的重写方法将在子类构造函数运行之前被调用。如果重写方法依赖于子类构造函数执行的任何初始化，则该方法将无法正常工作。

这是一个示例说明：

public class ConstructorCallsOverride {
    public static void main(String[] args) {

        abstract class Base {
            Base() {
                overrideMe();
            }
            abstract void overrideMe(); 
        }

        class Child extends Base {

            final int x;

            Child(int x) {
                this.x = x;
            }

            @Override
            void overrideMe() {
                System.out.println(x);
            }
        }
        new Child(42); // prints "0"
    }
}

在此，当Base构造函数调用时overrideMe，Child尚未完成对的初始化final int x，并且该方法获得了错误的值。这几乎肯定会导致错误和错误。

关于具有许多参数的对象构造
具有许多参数的构造函数可能导致较差的可读性，并且存在更好的替代方法。

这是来自Effective Java 2nd Edition，项目2的引用：面对许多构造函数参数时，请考虑一个构造器模式：

传统上，程序员使用伸缩构造函数模式，在这种模式下，你只为构造函数提供必需的参数，另一个为单个可选参数，第三个为两个可选参数，依此类推…

伸缩构造函数模式本质上是这样的：

public class Telescope {
    final String name;
    final int levels;
    final boolean isAdjustable;

    public Telescope(String name) {
        this(name, 5);
    }
    public Telescope(String name, int levels) {
        this(name, levels, false);
    }
    public Telescope(String name, int levels, boolean isAdjustable) {       
        this.name = name;
        this.levels = levels;
        this.isAdjustable = isAdjustable;
    }
}

现在，你可以执行以下任一操作：

new Telescope("X/1999");
new Telescope("X/1999", 13);
new Telescope("X/1999", 13, true);

但是，你目前不能仅设置name和isAdjustable，并保留levels默认值。你可以提供更多的构造函数重载，但是显然，数量会随着参数数量的增长而爆炸，甚至可能包含多个boolean和int参数，这确实会使事情一团糟。

如你所见，这不是一个令人愉快的模式，而且使用起来也不那么令人愉快（“ true”在这里是什么意思？13是什么？）。

Bloch建议使用构建器模式，这将使你可以编写如下代码：

Telescope telly = new Telescope.Builder("X/1999").setAdjustable(true).build();

请注意，现在参数已命名，你可以按所需的任何顺序设置它们，也可以跳过要保留为默认值的参数。这肯定比伸缩构造函数好得多，尤其是当存在大量属于许多相同类型的参数时。