admin管理员组文章数量:1584215
本文翻译自:Java - No enclosing instance of type Foo is accessible
I have the following code: 我有以下代码:
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!");
}
}
I know Thing
does nothing, but my Hello, World program compiles just fine without it. 我知道Thing
不会执行任何操作,但是如果没有它,我的Hello,World程序可以正常编译。 It's only my defined classes that are failing on me. 只有我定义的类对我不利。
And it refuses to compile. 而且它拒绝编译。 I get No enclosing instance of type Hello is accessible."
at the line that creates a new Thing. I'm guessing either: 在创建新的Thing的那一行中,我No enclosing instance of type Hello is accessible."
看到No enclosing instance of type Hello is accessible."
- I have system level problems (either in DrJava or my Java install) or 我有系统级别的问题(在DrJava或Java安装中)或
- I have some basic misunderstanding of how to construct a working program in java. 我对如何在Java中构建工作程序有一些基本的误解。
Any ideas? 有任何想法吗?
#1楼
参考:https://stackoom/question/e79E/Java-无法访问类型为Foo的封闭实例
#2楼
Lets understand it with the following simple example. 让我们通过下面的简单示例来理解它。 This happens because this is NON-STATIC INNER CLASS. 发生这种情况是因为这是非静态内部类。 You should need the instance of outer class. 您应该需要外部类的实例。
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");
}
}
}
#3楼
Well... so many good answers but i wanna to add more on it. 好吧...这么多好答案,但我想补充更多。 A brief look on Inner class in Java- Java allows us to define a class within another class and Being able to nest classes in this way has certain advantages: 对Java内部类的简要介绍-Java使我们能够在另一个类中定义一个类,并且能够以这种方式嵌套类具有某些优点:
It can hide(It increases encapsulation) the class from other classes - especially relevant if the class is only being used by the class it is contained within. 它可以从其他类中隐藏(增加封装)该类-如果该类仅由包含在其中的类使用,则尤其相关。 In this case there is no need for the outside world to know about it. 在这种情况下,外界无需了解它。
It can make code more maintainable as the classes are logically grouped together around where they are needed. 由于类在需要的地方按逻辑分组在一起,因此可以使代码更易于维护 。
The inner class has access to the instance variables and methods of its containing class. 内部类可以访问其包含类的实例变量和方法。
We have mainly three types of Inner Classes
我们主要有三种类型的Inner Classes
- Local inner 局部内部
- Static Inner Class 静态内层
- Anonymous Inner Class 匿名内部阶层
Some of the important points to be remember 要记住的一些重要点
- We need class object to access the Local Inner Class in which it exist. 我们需要类对象来访问它所在的本地内部类。
- Static Inner Class get directly accessed same as like any other static method of the same class in which it is exists. 可以直接访问静态内部类,就像它所在的相同类的任何其他静态方法一样。
- Anonymous Inner Class are not visible to out side world as well as to the other methods or classes of the same class(in which it is exist) and it is used on the point where it is declared. 匿名内部类对于外部世界以及同一个类(存在该类)的其他方法或类不可见,并且在声明该点时使用。
Let`s try to see the above concepts practically_ 让我们尝试实际了解以上概念_
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!");
}
}
}
I hope this will helps to everyone. 希望对大家有帮助。 Please refer for more 请参考更多
#4楼
Thing
is an inner class with an automatic connection to an instance of Hello
. Thing
是一个内部类 ,它具有与Hello
实例的自动连接。 You get a compile error because there is no instance of Hello
for it to attach to. 您会收到一个编译错误,因为没有Hello
实例可以附加到该实例。 You can fix it most easily by changing it to a static nested class which has no connection: 通过将其更改为没有连接的静态嵌套类 ,可以最轻松地修复它:
static class Thing
#5楼
static class Thing
will make your program work. static class Thing
将使您的程序正常工作。
As it is, you've got Thing
as an inner class, which (by definition) is associated with a particular instance of Hello
(even if it never uses or refers to it), which means it's an error to say new Thing();
实际上,您已经将Thing
作为内部类,(根据定义)它与Hello
的特定实例相关联(即使它从不使用或引用它),这意味着说new Thing();
是错误的new Thing();
without having a particular Hello
instance in scope. 范围内没有特定的Hello
实例。
If you declare it as a static class instead, then it's a "nested" class, which doesn't need a particular Hello
instance. 如果改为将其声明为静态类,则它是“嵌套”类,不需要特定的Hello
实例。
#6楼
You've declared the class Thing
as a non-static inner class. 您已将Thing
类声明为非静态内部类。 That means it must be associated with an instance of the Hello
class. 这意味着它必须与Hello
类的实例相关联。
In your code, you're trying to create an instance of Thing
from a static context. 在您的代码中,您尝试从静态上下文创建Thing
的实例。 That is what the compiler is complaining about. 这就是编译器所抱怨的。
There are a few possible solutions. 有几种可能的解决方案。 Which solution to use depends on what you want to achieve. 使用哪种解决方案取决于您要实现的目标。
Move
Thing
out of theHello
class. 将Thing
移出Hello
类。Change
Thing
to be astatic
nested class. 将Thing
更改为static
嵌套类。static class Thing
Create an instance of
Hello
before creating an instance ofThing
. 创建实例Hello
创建实例前Thing
。public static void main(String[] args) { Hello h = new Hello(); Thing thing1 = h.new Thing(); // hope this syntax is right, typing on the fly :P }
The last solution (a non-static nested class) would be mandatory if any instance of Thing
depended on an instance of Hello
to be meaningful. 如果Thing
任何实例都依赖Hello
实例,那么最后一个解决方案( 非静态嵌套类)将是必需的。 For example, if we had: 例如,如果我们有:
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;
}
}
...
}
any raw attempt to create an object of class Thing
, as in: 创建Thing
类的对象的任何原始尝试,例如:
Thing t = new Thing(31);
would be problematic, since there wouldn't be an obvious enormous
value to test 31 against it. 这将是有问题的,因为测试31并没有明显的enormous
价值。 An instance h
of the Hello
outer class is necessary to provide this h.enormous
value: Hello
外部类的实例h
对于提供此h.enormous
值是必需的:
...
Hello h = new Hello(30);
...
Thing t = h.new Thing(31);
...
Because it doesn't mean a Thing
if it doesn't have a Hello
. 因为它没有Hello
并不意味着Thing
。
For more information on nested/inner classes: Nested Classes (The Java Tutorials) 有关嵌套/内部类的更多信息: 嵌套类(Java教程)
版权声明:本文标题:Java-无法访问类型为Foo的封闭实例 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://www.elefans.com/dongtai/1727934996a1138825.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论