我很想了解为什么下面的实例化不会编译:
Superclass.Subclass myObject = new Superclass.Subclass();
错误消息如下:
No enclosing instance of type Superclass is accessible. Must qualify the allocation with an enclosing instance of type Superclass (e.g. x.new A() where x is an instance of Superclass).
包围实例是什么意思?为什么有这个必要?
这条消息似乎是在声
我想要创建一个包含实体的模拟。有两种实体,复杂的和简单的。当我实例化一个简单的模拟时,我希望这个简单的实体被实例化,当我实例化一个复杂的模拟时,我希望这个复杂的实体被实例化。
实体:
class ComplexEntity extends Entity {
public ComplexEntity(){}
}
class SimpleEntity extends Entity {
public SimpleEntity(){}
}
class Entity {
public Entity(){}
}
模拟:
class ComplexSimulation exte
考虑下面的例子,为什么当对继承内部类中的静态变量没有任何限制时,为什么我们被限制在内部类中声明静态成员变量?
public class Outer {
public class Inner {
public static String notAllowed;
/* Above line give following compilation error
The field notAllowed cannot be declared static in a non-static inner type, unless initializ
我想问一下,当引用内部类或静态嵌套类时,何时需要显式编写外部类的名称。
例如:
class B {
static class Inner {
int a = 10;
}
}
class Test extends B {
public static void main(String[] args) {
Test t = new Test();
Inner obj = new Inner();
System.out.println(obj.a);
}
}
我想问的是在什么情况下需要写:
B.Inner
我想创建一个只能从超类的实例访问的子类,但不能从超类本身访问,以确保超类的变量已经初始化。例如:
public class SuperClass
{
int num;
SuperClass(int number){
num = number;
}
//Make this\/ accessible from instance only
class SubClass
{
SubClass(){}
public int read(){
retur
我知道嵌套类没有静态成员,
class OuterClass {
class InnerClass {
private static int x = 0; // this is error
}
}
但当我们最终宣布
class OuterClass {
class InnerClass {
private static final int x = 0; // ok
}
}
它与最后一个关键字有关吗?因为变量不能再改变了吗?还是还有别的原因?
我在Java中遇到以下问题,如果内部类在外部类的方法中声明,如何初始化内部类的实例?在下面的例子中我遇到了一个编译错误。非常感谢。
class Outer {
public int a = 1;
private int b = 2;
public void method(final int c){
int d = 3;
class Inner{
private void iMethod(int e){
System.out.println("a = " + a);
不幸的是,我已经五年没有编写Java代码了,我完全不记得下面的代码是如何工作的或为什么工作的。
我偶然发现了一个类似的例子,并将其分解为这个例子。重点放在注释下面的部分:我没有得到构造函数表示法,后面是双括号中的块。不幸的是,我无法在Java文档中找到任何东西,也无法通过使用Google找到任何东西(我应该搜索哪些单词?)
package syntaxtest;
public class Main {
public static void main(String[] args) {
// What kind of notation is this?
在我的Java类中,我使用的代码类似于以下代码:
public class SomeClass {
private int someValue;
void incrementValue() {
someValue++;
}
public abstract static class InnerClass {
private final SomeClass toRunOn;
public InnerClass(SomeClass obj) {
toRunOn = obj;
静态内部类中非静态字段的实时效用是什么?另外,静态内部类的实例创建是如何工作的:
class Outer {
static class Inner {
public final String text = "Inner";
}
}
public class A {
public static void main(String[] args) {
System.out.println(new Outer.Inner().text);
}
}
今天我在调试一个失败的clang版本。这个构建基本上失败了,因为is_default_constructible的计算结果是false。在将问题一分为二的几个小时后,我将问题减少到了最小的情况:
#include <type_traits>
#include <string>
namespace A {
// This has been extracted from an old (outdated(?))
// implementation of an optional type
struct empty_t {};
templa
我为我的错误道歉,因为这是我在这里的第一篇帖子。这是一个基本的问题,但我不明白我看到的答案。在以下Java代码中:
public class RAPVAR_XDATA_TYPE{
public class datacfg{
public int datacfg_len;
public float datacfg_val;
}
public class numdata{
public int numdata_len;
public float num
public class Main {
private JLabel lb = new JLabel();
private JButton btn = new JButton();
public class events extends JFrame{
public events(){
setLayout(new FlowLayout());
btn = new JButton("Click for text");
lb = new JLabel();
为什么Bill Pugh的单例设计模式线程是安全的?
public class Logger {
private Logger() {
// private constructor
}
// static inner class - inner classes are not loaded until they are
// referenced.
private static class LoggerHolder {
private static Logger logger = new Logger();
}
如果在方法中定义的Inner class需要使用local variable,为什么我需要将它声明为final?
示例:
class MyOuter2 {
private String x = "Outer2";
void doStuff() {
final String y = "Hello World";
final class MyInner {
String z = y;
public void seeOuter() {
System.out.println("Ou
我需要从静态类中的方法引用顶级类的变量。
此方法应该作用于顶级类的唯一实例,因此感觉我不应该在静态类中实例化顶级类。
基本上我想要像这样的东西
public class TopLevel{
// private
int innerV
public static class Inner implements X {
for(i=0; i<innerV,i++){
doSomething
}
}
}
在for循环和类似的地方,是否可以只说this.innerV或类似的东西?
import javax.swing.*;
import javax.swing.event.*;
public class NewGUIStuff{
public static void main(String args[]){
NewGUIStuff gui = new NewGUIStuff();
gui.go();
}
class handlesListListeners implements ListSelectionListener{
public void valueChanged(ListSelect
我有一个简单的嵌套类A (在C中,我使用一个struct)。我想提供A类的默认对象A.DEFAULT,而不必每次调用构造函数。所以我的想法是:
class MyApplication {
class A {
int x;
double y;
public static final A DEFAULT = new A(0, 0.0);
public A(int x, double y) {
this.x = x;
this.y = y;
}
}
这是我遇到的一个问题的简化版本。我正在尝试在类数据库中创建一个ProduceItem数组。我已经概述了我在尝试过程中遇到的警告和问题。提前感谢您的帮助。
import javax.swing.*;
import java.awt.*;
public class Test{
public static void main(String[] args) {
//attempt 1:
//database a;
// Warning: local variable a is not used.
// Warning: Null pointer access:
在方法中定义一个新的匿名类,然后将一个实例分配给外部类私有字段(如下面的代码中的注释)是合法的吗?我正在学习Java,并试图弄清这背后的原因。谢谢!
public class Outer{
private int id;
private String name;
private SwingWorker doSomething; //Is it ok not to include it in the constructor?
public Outer (int id, String name){
//constructor, but didn't
我有这段代码,编译器用NullPointerException返回,在这里我尝试创建BtnAct。我读过很多关于初始化的文章,但仍然没有看到初始化内部类的顺序。有人能帮忙吗?
public class BaseClass{
static Myclass myClass;
public static void main(){
myClass = new MyClass;
}
}
class MyClass{
NewClass newClass;
public MyClass(){
newClass = new NewClas
在方法中,主是具有在给定字符串中返回数字数量的方法数量的类计数器。
public static void main(String... args) {
class Counter{
static final String numbers="0123456789";
int quantity(String main){
int i=0;
for (char c:main.toCharArray()){
if (numbers.contains(Characte
public class OuterClass extends Something{
private int unit = 0;
private void methodX(int num){
//Do something here
}
public static class InnerClass extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
class Outer {
class Inner {
}
}
public class Demo {
public static void main(String args[]) {
Outer o = new Outer();
Outer.Inner inner = o.new Inner();
}
}
我为Inner类对象创建引用的方式类似于访问Outer类中的static成员?
你能解释一下背后的机制吗?
public class Test {
public enum Directions {
NORTH, WEST, SOUTH, EAST
}
static final Directions D1 = Directions.NORTH;
static class Inner {
static final Directions D2 = Directions.NORTH;
}
class Inner2 {
static final Directions D3 = Directions.NORTH;
我有一个Java内部类的问题,我搞不清楚。假设你有
class Outer
{
int outer = 0;
class Inner
{
int inner = Outer.this.outer; //(or just outer as it is not shadowed)
inner = 3; //or whatever, even outer = 3
}
}
好吧,当我写最后一个赋值时,我得到了编译错误
Syntax error on token ";", , expected
在先例线上。
我有以下代码:
// If CheckBox is toggled, update the planet it is tagged with.
checkBox.setOnClickListener( new View.OnClickListener() {
public void onClick(View v) {
CheckBox cb = (CheckBox) v ;
Planet planet = (Planet) cb.getTag();
planet.setC
abstract class MyClass{
static class StaticClass{
public void showAdd(){
System.out.println(" show add");
}
}
}
public class SampleClass extends MyClass{
public static void main(String[] args){
MyClass myClass = new SampleClass();