我有以下代码:
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中构建一个工作程序有一些基本的误解。
什么好主意吗?
当前回答
让我们用下面的简单例子来理解它。 这是因为它是非静态的内部类。您应该需要外部类的实例。
public class PQ {
public static void main(String[] args) {
// create dog object here
Dog dog = new PQ().new Dog();
//OR
PQ pq = new PQ();
Dog dog1 = pq.new Dog();
}
abstract class Animal {
abstract void checkup();
}
class Dog extends Animal {
@Override
void checkup() {
System.out.println("Dog checkup");
}
}
class Cat extends Animal {
@Override
void checkup() {
System.out.println("Cat Checkup");
}
}
}
其他回答
嗯…很多很好的答案，但我想补充更多。简要介绍Java中的内部类——Java允许我们在另一个类和类中定义一个类 能够以这种方式嵌套类有一定的优势:
它可以对其他类隐藏(它增加了封装性)类-特别是当类只被包含它的类使用时。在这种情况下，没有必要让外界知道。 它可以使代码更具可维护性，因为类是根据需要的位置逻辑地分组在一起的。 内部类可以访问其包含类的实例变量和方法。
我们主要有三种类型的内部类
当地的内心 静态内部类 匿名内部类
要记住一些要点
我们需要类对象来访问它所在的局部内部类。 静态内部类可以直接访问，就像它存在于同一类的任何其他静态方法一样。 匿名内部类对外部世界以及同一类(存在于其中)的其他方法或类都是不可见的，并且在声明时使用它。
让我们试着实际地看待上面的概念_
public class MyInnerClass {
public static void main(String args[]) throws InterruptedException {
// direct access to inner class method
new MyInnerClass.StaticInnerClass().staticInnerClassMethod();
// static inner class reference object
StaticInnerClass staticInnerclass = new StaticInnerClass();
staticInnerclass.staticInnerClassMethod();
// access local inner class
LocalInnerClass localInnerClass = new MyInnerClass().new LocalInnerClass();
localInnerClass.localInnerClassMethod();
/*
* Pay attention to the opening curly braces and the fact that there's a
* semicolon at the very end, once the anonymous class is created:
*/
/*
AnonymousClass anonymousClass = new AnonymousClass() {
// your code goes here...
};*/
}
// static inner class
static class StaticInnerClass {
public void staticInnerClassMethod() {
System.out.println("Hay... from Static Inner class!");
}
}
// local inner class
class LocalInnerClass {
public void localInnerClassMethod() {
System.out.println("Hay... from local Inner class!");
}
}
}
我希望这对大家都有帮助。详情请参考
Thing是一个内部类，具有到Hello实例的自动连接。您会得到一个编译错误，因为没有Hello实例供它附加。你可以通过将它更改为一个没有连接的静态嵌套类来最容易地修复它:
static class Thing
实际上你不需要将任何东西声明为静态的，但是你必须指定一些外围实例，可以隐式地在同一个类中，显式地在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);
}
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!");
}
}
在我的例子中，这是因为多了一个'}'
