Java是否隐式地将构造函数（或对象）与新运算符一起使用？

今天我学到了可以在分隔符（

，或“点运算符”）旁边使用

新的

运算符。这让我怀疑Java是否对所有出现的新操作符隐式地使用相同的技术

下面的语句创建一个新的“InnerClass对象”。它使用

.new

使用一个新的ParentClass对象来实现这一点。但是，此语句中的第一个

new

运算符前面没有构造函数（或对象）。那么，Java是否在编译时添加了一个？我试图在这个语句中显式添加一个（

Main（）

），但代码无法编译

ParentClass.InnerClass ic = new ParentClass().new InnerClass();

形式

someObject.new InnerClass()

仅用于。内部类的实例必须与其封闭类的实例相关联。通常，封闭实例是

this

，不需要虚线表示法，但是当您想要显式创建与不同对象关联的内部类的实例时，可以使用上面的语法

Java中的大多数类不是内部类。不需要封闭实例，因此Java不会在所有

new

调用之前隐式插入

newsomething（）

。（如果它这样做了，它必须在插入的调用之前插入

new Something（）

，在这些调用之前插入

new Something（）

，而您根本无法构造任何东西。）

表单

someObject.new InnerClass()

仅用于。内部类的实例必须与其封闭类的实例相关联。通常，封闭实例是

this

，不需要虚线表示法，但是当您想要显式创建与不同对象关联的内部类的实例时，可以使用上面的语法

---

Java中的大多数类不是内部类。不需要封闭实例，因此Java不会在所有

new

调用之前隐式插入

newsomething（）

。（如果它这样做了，它必须在插入的调用之前插入

new Something（）

，在这些调用之前插入

new Something（）

，并且您根本无法构造任何东西。）

外部类和静态内部类可以自己创建，而不需要任何父元素。但非静态内部类需要是父元素的一部分。因为外部类和静态类不存在父元素的概念，所以不可能引用该父元素

---

提供此表单是为了允许您一步构造外部和内部对象，并且只保留对内部对象的引用。我从未发现它有多大用处，但知道它的存在很方便。

外部类和静态内部类可以自己创建，而不需要任何父元素。但非静态内部类需要是父元素的一部分。因为外部类和静态类不存在父元素的概念，所以不可能引用该父元素

---

提供此表单是为了允许您一步构造外部和内部对象，并且只保留对内部对象的引用。我从来没有发现它有多大用处，但知道它的存在很方便。

我还没有研究过它的内部结构，但是让我们首先假设编译器添加了一个对象，以便在编译时继续新的操作。这意味着我们所有的类都是另一个类的内部类。因为它们不是在另一个类中声明的，所以情况并非如此。所以：不，它不会在编译时添加类似的内容

事实上，让我们来分析一下

public class Outer {

    String strHello = "Hello ^^";

    public void printHello() {
        System.out.println(strHello);
    }

    public static void main(String[] args) {

        // This will print: Hello ^^
        Outer outer = new Outer();
        outer.printHello();

        // This will print: Hello ^^
        new Outer().printHello();
    }
}

我猜你以前见过这样的代码。它只是调用实例化类的一个方法。点表示法也可用于访问变量和内部类。在上面，我们将其用于一个实例方法。使用关键字

static

可以共享类的所有实例甚至单独的类的方法和变量

public class Outer {

    static String strHello = "Hello ^^";

    public static void printHello() {
        System.out.println(strHello);
    }

    static class StaticInner {
    }

    static class Inner {
    }

    public static void main(String[] args) {

        // Prints: Hello ^^
        Outer.printHello();

        // Constructs a new Example.StaticInner
        Outer.StaticInner inner = new Outer.StaticInner();

        // Constructs a new Outer.Inner     
        Outer.Inner inner = new Example().new Inner();

        // Constructs a new Outer.Inner
        Example ex = new Example();
        Outer.Inner inner = ex.new Inner();
    }
}

---

上面的代码使用了一个静态的内部类，希望能够证明内部构造函数与任何其他构造函数一样。但是，因为它在另一个类中，我们需要通过另一个（外部）类访问它。它不是一个静态的内部类，那么由于访问修饰符的存在，我们需要使用一个实例来访问它。

我还没有看过它的内部结构，但我们首先假设编译器在编译时添加了一个新的对象。这意味着我们所有的类都是另一个类的内部类。因为它们不是在另一个类中声明的，所以情况并非如此。所以：不，它不会在编译时添加类似的内容

事实上，让我们来分析一下

public class Outer {

    String strHello = "Hello ^^";

    public void printHello() {
        System.out.println(strHello);
    }

    public static void main(String[] args) {

        // This will print: Hello ^^
        Outer outer = new Outer();
        outer.printHello();

        // This will print: Hello ^^
        new Outer().printHello();
    }
}

我猜你以前见过这样的代码。它只是调用实例化类的一个方法。点表示法也可用于访问变量和内部类。在上面，我们将其用于一个实例方法。使用关键字

static

可以共享类的所有实例甚至单独的类的方法和变量

public class Outer {

    static String strHello = "Hello ^^";

    public static void printHello() {
        System.out.println(strHello);
    }

    static class StaticInner {
    }

    static class Inner {
    }

    public static void main(String[] args) {

        // Prints: Hello ^^
        Outer.printHello();

        // Constructs a new Example.StaticInner
        Outer.StaticInner inner = new Outer.StaticInner();

        // Constructs a new Outer.Inner     
        Outer.Inner inner = new Example().new Inner();

        // Constructs a new Outer.Inner
        Example ex = new Example();
        Outer.Inner inner = ex.new Inner();
    }
}

上面的代码使用了一个静态的内部类，希望能够证明内部构造函数与任何其他构造函数一样。但是，因为它在另一个类中，我们需要通过另一个（外部）类访问它。它不是一个静态的内部类，由于访问修饰符的原因，我们需要使用一个实例来访问它。

可能重复的