我有以下代码:

class Hello {
    class Thing {
        public int size;

        Thing() {
            size = 0;
        }
    }

    public static void main(String[] args) {
        Thing thing1 = new Thing();
        System.out.println("Hello, World!");
    }
}

我知道Thing什么也不做,但是我的Hello, World程序没有它编译也很好。只有我定义的类不及格。

它拒绝编译。在创建一个新Thing的行中,我得到了Hello类型的No封闭实例。我猜是:

我有系统级的问题(在DrJava或我的Java安装)或 我对如何在java中构建一个工作程序有一些基本的误解。

什么好主意吗?


当前回答

您已经将类Thing声明为非静态内部类。这意味着它必须与Hello类的实例相关联。

在代码中,您试图从静态上下文中创建Thing的实例。这就是编译器抱怨的地方。

有一些可能的解决方案。使用哪种解决方案取决于您想要实现的目标。

将Thing移出Hello类。 将Thing更改为静态嵌套类。 静态类 在创建Thing实例之前,先创建Hello实例。 public static void main(String[] args) { Hello h = new Hello(); Thing thing1 = h.new Thing();//希望这个语法是正确的,键入在飞行 }

如果任何Thing的实例依赖于Hello的实例才有意义,那么最后一个解决方案(非静态嵌套类)将是强制性的。例如,如果我们有:

public class Hello {
    public int enormous;

    public Hello(int n) {
        enormous = n;
    }

    public class Thing {
        public int size;

        public Thing(int m) {
            if (m > enormous)
                size = enormous;
            else
                size = m;
        }
    }
    ...
}

任何创建Thing类对象的原始尝试,例如:

Thing t = new Thing(31);

这是有问题的,因为没有明显的巨大价值来测试31。需要一个Hello外部类的实例h来提供这个h.enormous值:

...
Hello h = new Hello(30);
...
Thing t = h.new Thing(31);
...

因为如果没有"你好"就不代表"事"了。

有关嵌套/内部类的更多信息: 嵌套类(Java教程)

其他回答

静态类Thing将使您的程序工作。

实际上,您已经将Thing作为内部类,它(根据定义)与Hello的特定实例相关联(即使它从未使用或引用它),这意味着说new Thing()是一个错误;而没有特定的Hello实例。

如果将其声明为静态类,则它是一个“嵌套”类,不需要特定的Hello实例。

Java 14之前 您必须添加静态关键字来从静态上下文访问类Thing。

class Hello {
    static class Thing {
        public int size;

        Thing() {
            size = 0;
        }
    }

    public static void main(String[] args) {
        Thing thing1 = new Thing();
        System.out.println("Hello, World!");
    }
}

Java 14 + 从Java 14开始,您可以使用内部记录类,它们是隐式静态的。所以你会有:

class Hello {
    record Thing(int size) { }

    public static void main(String[] args) {
        Thing thing1 = new Thing(0);
        System.out.println("Hello, World!");
    }
}

实际上你不需要将任何东西声明为静态的,但是你必须指定一些外围实例,可以隐式地在同一个类中,显式地在new之前,或者显式地在构造函数中。

class A {

    class B { 
        final A a = A.this;
    }

    class C extends B { }

    final B b = new B();
    final C c = new C();

}

class D extends A.B {

    public D(A a) {
        a.super();
    }

}

class E { 

    final A   a =     new A();
    final A.B b =   a.new B();
    final A.C c = b.a.new C();
    final D   d =     new D(a);

}

在我的例子中,这是因为多了一个'}'

朋友,试试这个吧(你也可以叫它Hello而不是Main)

class Thing {
  public int size;

    Thing() {
      size = 0;
    }
}


class Main {
  public static void main(String[] args) {
    Thing thing1 = new Thing();
      System.out.println("Hello, World!");
  }
}

这背后的想法是,你必须创建一个单独的类,包括静态void main (String[] args)方法。总结:你必须有一个类来创建你的对象,还有另一个类(在前一个类之外),你将在其中包括对象创建。如果将其命名为Main,则应该有一个名为Main.java的文件。如果您想将其命名为Hello,那么您的文件必须命名为Hello.java