Java 成员使用“初始化”；这"；

这是我的问题

class A{
  private B b = new B(this); // line 2

  A(){}
}

---

这只是一个ex.代码，工作正常。但是我怀疑

这个
是否用于当前引用（a的实例）。类初始化发生在获取类实例之前。那么，我们怎样才能把这个
放在第2行呢。我问初始化之前是否发生实例化？
当您创建类A的对象时，此
将显示其存在。实例变量在对象创建后分配，静态变量在类加载后以及任何对象创建前初始化。
不能在静态块中使用上述初始化

static {
    private B b = new B(this); // compiler error. you cannot use 'this' in static context.
}

此
将在创建A类对象时显示其存在。实例变量在对象创建后分配，静态变量在类加载后以及创建任何对象之前初始化。
不能在静态块中使用上述初始化

static {
    private B b = new B(this); // compiler error. you cannot use 'this' in static context.
}

此
使用正确。根本不需要调用构造函数。
此
使用正确。构造函数根本不需要调用。
不需要更改，一切都很好<代码>此

是对a的有效引用。

无需更改，一切正常

这是对a的有效引用。
这不是类初始化（尝试一步一步地调试
新的ClassA（）
），它实际上是实例初始化

如果构造函数（来自
ClassB
）从
ClassA
调用一些函数，这些函数访问
ClassA
中未初始化的某些字段，则可能会出现一些问题

Edit：这是在调用构造函数之前完成的。
这不是类初始化（尝试一步一步地调试
new ClassA（）
），它实际上是实例初始化

如果构造函数（来自
ClassB
）从
ClassA
调用一些函数，这些函数访问
ClassA
中未初始化的某些字段，则可能会出现一些问题

编辑：这是在调用构造函数之前完成的。
您提出了一个有趣的观点。下面是一个人为的教学示例，演示了在使用示例时可能发生的运行时问题

class A {
    private boolean isInitialized = false;
    private final B b             = new B(this);
    public A() {
        initialize();
    }
    private void initialize() {
        isInitialized = true;
    }
    public boolean isInitialize() {
        return isInitialized;
    }
    public B getB() {
        return b;
    }
}

class B {
    private boolean isInitialized = false;
    final private A a;
    public B(final A a) {
        this.a = a;
        initialize();
        System.out.println("inB:          a.isInitialize()=" + a.isInitialize());
    }
    private void initialize() {
        isInitialized = true;
    }
    public boolean isInitialize() {
        return isInitialized;
    }
}

public static void main(final String[] args) {
    final A a = new A();
    System.out.println("inMain:       a.isInitialize()=" + a.isInitialize());
    System.out.println("inMain:a.getB().isInitialize()=" + a.getB().isInitialize());
}

输出：

inB:          a.isInitialize()=false
inMain:       a.isInitialize()=true
inMain:a.getB().isInitialize()=true

在类B中使用传递的对类A的引用会有使用未完全初始化的对象的实际风险

小心点。
你提出了一个有趣的观点。下面是一个人为的教学示例，演示了在使用示例时可能发生的运行时问题

class A {
    private boolean isInitialized = false;
    private final B b             = new B(this);
    public A() {
        initialize();
    }
    private void initialize() {
        isInitialized = true;
    }
    public boolean isInitialize() {
        return isInitialized;
    }
    public B getB() {
        return b;
    }
}

class B {
    private boolean isInitialized = false;
    final private A a;
    public B(final A a) {
        this.a = a;
        initialize();
        System.out.println("inB:          a.isInitialize()=" + a.isInitialize());
    }
    private void initialize() {
        isInitialized = true;
    }
    public boolean isInitialize() {
        return isInitialized;
    }
}

public static void main(final String[] args) {
    final A a = new A();
    System.out.println("inMain:       a.isInitialize()=" + a.isInitialize());
    System.out.println("inMain:a.getB().isInitialize()=" + a.getB().isInitialize());
}

输出：

inB:          a.isInitialize()=false
inMain:       a.isInitialize()=true
inMain:a.getB().isInitialize()=true

在类B中使用传递的对类A的引用会有使用未完全初始化的对象的实际风险

小心。
实例初始化和类初始化是什么意思？实例初始化和类初始化是什么意思？