父类和子类的类（构造函数）的初始化顺序，两个类中都有多个构造函数

在派生类中，调用父类的一个构造函数。
要么在子构造函数的开头使用 construct 显式调用父构造函数，要么在编译器在构造函数的开头super替换它时隐式调用它。super();而且，如果父类没有不带参数的构造函数，那么代码会导致编译错误。
有关此的文档。

因此，对于有多少父构造函数以及哪些在子构造函数中被调用是没有不确定性的。

正如@zRrr 所写，如果在父构造函数中调用重写或子实现的方法，而父构造函数又使用尚未初始化的子字段，那么调用构造函数的顺序和类字段的初始化可能会出现问题。
例子：

public abstract class Animal
{
    private final String fullName;

    protected Animal()
    {
        fullName = "Animal " + getName();
    }

    public String getFullName()
    {
        return fullName;
    }

    protected abstract String getName();
}

public class Dog extends Animal
{
    private String thisName = "DDog";

    protected String getName()
    {
        return thisName;
    }
}

public static void main(String[] args)
{
    Animal animal = new Dog();
    System.out.println(animal.getFullName());
}

它会显示在屏幕上Animal null，因为在调用该方法的那一刻，getNameyDog字段thisName还没有被初始化。
创建animal时，默认构造函数 y 被调用Dog，这首先导致调用不带参数的构造函数 y Animal，然后才初始化该字段thisName。

这篇文章还有另一个例子：

public class Upper
{
    String upperString;

    public Upper()
    {
        Initializer.initialize(this);
    }
}

public class Lower extends Upper
{
    String lowerString = null;

    public Lower()
    {
        super();
        System.out.println("Upper:  " + upperString);
        System.out.println("Lower:  " + lowerString);
    }

    public static void main(final String[] args)
    {
        new Lower();
    }
}

public class Initializer
{
    static void initialize(final Upper anUpper)
    {
        if (anUpper instanceof Lower)
        {
            Lower lower = (Lower)anUpper;
            lower.lowerString = "lowerInited";
        }
        anUpper.upperString = "upperInited";
    }
}

屏幕将显示：

Upper:  upperInited
Lower:  null;

但是，如果您替换String lowerString = null;为String lowerString;，则输出将是：

Upper:  upperInited
Lower:  lowerInited

原始版本的问题是对的赋值null发生String lowerString = null;在调用父类的构造函数之后，而父类的构造函数又调用Initializer.initialize. 也就是说，lowerString首先写的是"lowerInited"，然后是null。

这两个示例都说明了由于对代码执行顺序的错误假设而引起的问题。很难理解这段代码中执行的是什么，这本身就表明在实践中不应该这样写代码。

我认为这是顺序：

/**
 * Порядок инициализации таков:
 * [1]. Статические поля базового класса;
 * [2]. Статический блок инициализации базового класса;
 * [3]. Статические поля производного класса;
 * [4]. Статический блок инициализации производного класса;
 * [5]. Поля (Глобальные переменные) базового класса;
 * [6]. Нестатический блок инициализации базового класса;
 * [7]. Конструктор базового класса [если у родителя нет конструктора без аргументов, то код приведёт к ошибке компиляции];
 * [8]. Поля (Глобальные переменные)  производного класса;
 * [9]. Нестатический блок инициализации производного класса;
 * [10]. Конструктор производного класса;
 */

class Base {

    //[1] transient переменные и статические поля не сериализуются
    private static Base instance = new Base("))(("); //BASE = 0 //
    public static int _baseStaticInsect = 111; //сокрыто, доступ Base._baseStaticBase
    private static final int DELTA = 2;
    private static int BASE = 3;

    //[2]
    static {
        System.out.println("[static instance class initializer] " + Inherit.class.getSimpleName());
    }

    //[5]
    private int i = 5;
    protected int j; //mod:protected-internal
    int x;
    int internal; //mod:package
    public int iInc;

    //[6]
    {
        System.out.println("[instance class initializer] " + this.getClass().getSimpleName());
    }


    //[7]
    //private недоступен  из вне, нельзя создать без рефлексии
    //если у нет конструктора без аргументов или он приватный, то код приведёт к ошибке компиляции];
    public Base() {
        System.out.println("[constructor] " + this.getClass().getSimpleName());
        x = BASE + DELTA;
    }

    //[7]
    public Base(String data) {
        this();
        System.out.println("[constructor] (String)" + this.getClass().getSimpleName());
        System.out.println(data);

    }

    static int printInit(String s) {
        return -1;
    }
}

public class Inherit extends Base {

    //[3]
    public static int _baseStaticBase = 222;
    public static int _baseStaticInherit = 4;

    //[4]
    static {
        System.out.println("[static class initializer] " + Inherit.class.getSimpleName());
    }

    //[8]
    private int internal;

    public int Integnal() { //getInternal
        return this.internal;
    }

    private boolean internalFlag;

    public boolean isInternalFlag() {
        return internalFlag;
    }

    //[9]
    {
        System.out.println("[instance class initializer] Inherit " + this.getClass().getSimpleName());
    }

    //[10]
    public Inherit() {
        this("start");
        System.out.println("Inherit constructor");
    }

    //[10]
    public Inherit(String data) {
        System.out.println("Inherit constructor data");
    }

    public static void main(String[] args) {
        Base base = new Base();
        Inherit inherit = new Inherit();
    }

}