不理解嵌套类型

Question

我正在准备 SCJP，在阅读有关嵌套类型的内容时我感到很困惑。有一个简单的问题，我无法理解结果。

public class Outer {
    private int innerCounter;

    class Inner {
        Inner() {
            innerCounter++;
        }

        public String toString() {
            return String.valueOf(innerCounter);
        }
    }

    private void multiply() {
        Inner inner = new Inner();
        this.new Inner();
        System.out.print(inner);
        inner = new Outer().new Inner();
        System.out.println(inner);
    }

    public static void main(String[] args) {
        new Outer().multiply();
    }
}

它打印

21

Knowing that the counter is not static, how are the front of the four object recognizes as one object?

Answer 1

非静态内部类可以访问其外部类的所有成员。就好像它实际上被定义为：

class Outer {

    private int innerCount;

    class Inner() {
        private final Outer owner;

        public Inner(Outer owner) {
            this.owner = owner;
            this.owner.innerCount++;
        }
    }

    private void multiply() {
        Inner inner = new Inner(this);
        ...
    }
}

所以让我注释一下你的方法：

private void multiply() {
    // this.innerCount = 0

    Inner inner = new Inner();
    // this.innerCount = 1

    this.new Inner();
    // this.innerCount = 2

    System.out.print(inner);  // Prints "2"

    // Creates a new Outer (with a separate innerCount)
    // then uses that to create a new Inner, which updates
    // the new innerCount
    inner = new Outer().new Inner();
    // inner.innerCount = 1

    System.out.println(inner);  // Prints "1"
}

Answer 2

我假设您正在谈论内部对象。
好吧，它们不被视为一个对象，但它们链接到同一个外部对象（this）

Answer 3

实例化非静态内部类需要引用“外部”类。对于 multiply 方法，您已经有一个活跃的 Outer 实例，因此 new Inner() 和 this 都有。 new Inner() 引用相同的 Outer 对象，但它们本身是唯一的对象。基本上，所有嵌套的非静态类实例在内部总是绑定到Outer 类实例。

Answer 4

我不明白你所说的“两个第一个对象”，但是
innerCounter 是外部类的一个字段。

在代码中，您创建了两个 Outer 实例 - 这里 new Outer().multiply(); 和这里 inner = new Outer().new Inner();。

第一个 Outer 实例的 innerCounter 通过调用 Inner 构造函数两次（Inner inner = new Inner(); 和 this.new Inner();)，第二个 - 仅一次 (inner = new Outer().new Inner();)。

因此，您将得到 2 和 1 作为输出。

Answer 5

Inner inner = new Inner();
Inner inner = this.new Inner();

上面两者是相同的，因为两者都引用当前运行的 Outer 实例。
与下面相同：

private int number;

public int getNumber(){
    return this.number;
}

public int getNumber(){
    return number;
}

这里两个方法也引用同一个实例，因此 this 不会影响输出。

Answer 6

我不明白你的困惑在哪里，但我会尝试解释为什么它打印 21。
请参阅内联注释

Note: objects are named for explanation sake.

public class Outer {
private int innerCounter;


类 Inner {
    内部（）{
        内部计数器++；
    }

public String toString() {
    return String.valueOf(innerCounter);
}

 }
私人无效乘法（）{

    Inner inner = new Inner();//Step2: 创建第一个内部对象

    //我们称之为innerA

    //注意innerA是使用outerA创建的

    //增加outerA的innerCount变量

    this.new Inner(); //step3 创建第二个内部对象

    //我们称之为innerB

    //注意innerB是使用outerA创建的

    //增加outerA的innerCount变量
System.out.print(inner); //step 3 print innerCount from outerA
//With the two increments done, prints 2
inner = new Outer().new Inner(); //step4 create second outer object
//Lets call it outerB.
//Lets call this third inner object as InnerC
//InnerC creation increments OuterB's innerCount variable (so value 1)
//Assigned now to the old reference
System.out.println(inner); // prints the value of innerC

}
 public static void main(String[] args) {

    new Outer().multiply(); //Step1：创建第一个外部对象

      //我们称之为OuterA
 }

}