Java 使用外部类访问静态类成员

我有这样的代码，我需要在

getInnerS（）

方法中访问静态类

InnerClass

的

mysample

变量，该方法位于

NestedClass

中。我试图通过为

InnerClass

创建一个新对象来访问它，但是我得到了

java.lang.StackOverflowerError

public class NestedClass{
    private String outer = "Outer Class"; //NestedClass instance variable
    NestedClass.InnerClass innerClass = new NestedClass.InnerClass();

    void getOuterS(){
        System.out.println(outer); 
    }
    void getInnerS(){
        System.out.println(innerClass.mysample);
    }
    static class InnerClass{
        private String mysample = "Inner Class"; //InnerClass instance variable,
        NestedClass a = new NestedClass();
        void getIn(){
            System.out.println(mysample);
        }
        void getOut(){
            System.out.println(a.outer);
        }
    }
    public static void main(String[] args){
         NestedClass nestedClass = new NestedClass();
         NestedClass.InnerClass nestedInner = new NestedClass.InnerClass(); 
         nestedClass.getOuterS();
         nestedClass.getInnerS();
         nestedInner.getIn();
         nestedInner.getOut();
    }
}

---

在

内部类中

构造函数：

NestedClass a = new NestedClass(); 

因此，您创建了一个新的

NestedClass

，它创建了一个新的

InnerClass

，它自己创建了自己的

NestedClass

，以及相应的

InnerClass

。。。。难怪堆栈溢出

如果要访问封闭类，应使用（inside

InnerClass

方法）

---

在

内部类中

构造函数：

NestedClass a = new NestedClass(); 

因此，您创建了一个新的

NestedClass

，它创建了一个新的

InnerClass

，它自己创建了自己的

NestedClass

，以及相应的

InnerClass

。。。。难怪堆栈溢出

如果要访问封闭类，应使用（inside

InnerClass

方法）

在静态中，InnerClass类创建NestedClass的实例，因为InnerClass是静态的，所以这是一个循环

InnerClass不需要是静态的，这应该可以工作

public class NestedClass {
private String outer = "Outer Class"; //NestedClass instance variable
NestedClass.InnerClass innerClass = new NestedClass.InnerClass();

void getOuterS(){
    System.out.println(outer); 
}
void getInnerS(){
    System.out.println(innerClass.mysample);
}
class InnerClass{
    private String mysample = "Inner Class"; //InnerClass instance variable,
    NestedClass a = NestedClass.this;
    void getIn(){
        System.out.println(mysample);
    }
    void getOut(){
        System.out.println(a.outer);
    }
}
public static void main(String[] args){
     NestedClass nestedClass = new NestedClass();
     NestedClass.InnerClass nestedInner = nestedClass.innerClass; 
     nestedClass.getOuterS();
     nestedClass.getInnerS();
     nestedInner.getIn();
     nestedInner.getOut();
}


}

在静态中，InnerClass类创建NestedClass的实例，因为InnerClass是静态的，所以这是一个循环

InnerClass不需要是静态的，这应该可以工作

public class NestedClass {
private String outer = "Outer Class"; //NestedClass instance variable
NestedClass.InnerClass innerClass = new NestedClass.InnerClass();

void getOuterS(){
    System.out.println(outer); 
}
void getInnerS(){
    System.out.println(innerClass.mysample);
}
class InnerClass{
    private String mysample = "Inner Class"; //InnerClass instance variable,
    NestedClass a = NestedClass.this;
    void getIn(){
        System.out.println(mysample);
    }
    void getOut(){
        System.out.println(a.outer);
    }
}
public static void main(String[] args){
     NestedClass nestedClass = new NestedClass();
     NestedClass.InnerClass nestedInner = nestedClass.innerClass; 
     nestedClass.getOuterS();
     nestedClass.getInnerS();
     nestedInner.getIn();
     nestedInner.getOut();
}


}

---

使用此解决方案，成员类是静态的。为了更好地进行比较，您可以阅读

静态嵌套类（说明）

静态嵌套类无权访问外部类的非静态字段和方法，这些字段和方法在某些方面类似于类中定义的静态方法。只能通过外部类的实例引用来访问非静态字段和方法。在这方面，静态嵌套类与任何其他顶级类非常相似

此外，静态嵌套类可以访问外部类的任何静态方法，包括私有方法

这些类的好处主要在于对实体进行逻辑分组，以改进封装，并节省类空间

public class NestedClass{
  private static String outer = "Outer Class"; //NestedClass instance variable
  InnerClass innerClass = new InnerClass();

  void getOuterS(){
    System.out.println(outer);
  }
  void getInnerS(){
    System.out.println(InnerClass.mysample);
  }
  InnerClass getInner(){
    return innerClass;
  }
  static class InnerClass{
    private static String mysample = "Inner Class"; //InnerClass instance variable,
     void getIn(){
      System.out.println(mysample);
    }
    void getOut(){
      System.out.println(outer); //access a static member
    }
  }
  public static void main(String[] args){
    NestedClass nestedClass = new NestedClass();
    NestedClass.InnerClass nestedInner = nestedClass.getInner();
    nestedClass.getOuterS();
    nestedClass.getInnerS();
    nestedInner.getIn();
    nestedInner.getOut();
  }
}

---

使用此解决方案，成员类是静态的。为了更好地进行比较，您可以阅读

静态嵌套类（说明）

静态嵌套类无权访问外部类的非静态字段和方法，这些字段和方法在某些方面类似于类中定义的静态方法。只能通过外部类的实例引用来访问非静态字段和方法。在这方面，静态嵌套类与任何其他顶级类非常相似

此外，静态嵌套类可以访问外部类的任何静态方法，包括私有方法

这些类的好处主要在于对实体进行逻辑分组，以改进封装，并节省类空间

public class NestedClass{
  private static String outer = "Outer Class"; //NestedClass instance variable
  InnerClass innerClass = new InnerClass();

  void getOuterS(){
    System.out.println(outer);
  }
  void getInnerS(){
    System.out.println(InnerClass.mysample);
  }
  InnerClass getInner(){
    return innerClass;
  }
  static class InnerClass{
    private static String mysample = "Inner Class"; //InnerClass instance variable,
     void getIn(){
      System.out.println(mysample);
    }
    void getOut(){
      System.out.println(outer); //access a static member
    }
  }
  public static void main(String[] args){
    NestedClass nestedClass = new NestedClass();
    NestedClass.InnerClass nestedInner = nestedClass.getInner();
    nestedClass.getOuterS();
    nestedClass.getInnerS();
    nestedInner.getIn();
    nestedInner.getOut();
  }
}

---

我更改并删除了NestedClass a=新NestedClass（）；并更改为System.out.println（NestedClass.this.outer）；在内部类中，但我收到编译错误，说“范围内没有可访问的NestedClass类型的封闭实例”，我更改并删除了NestedClass a=new NestedClass（）；并更改为System.out.println（NestedClass.this.outer）；在内部类中，但我收到一个编译错误，它说“在作用域中无法访问NestedClass类型的封闭实例”非常感谢…Nahuel Fouilleul我知道了…如果你不介意的话，你能说一下我们为什么要在那里使用它吗…？+1用于删除静态的，允许

NestedClass。如果内部类是静态的，它就不能访问外部类的非静态成员，但是如果不是，至少有一个外部类的实例可以访问，创建嵌套实例的实例。抱歉，如果不清楚，也许其他人可以解释betterA静态内部类与普通外部类完全相同，只是它的名称隐藏在父类下面。它的唯一目的是允许快速创建类，而不必为每个类创建新文件。没有static这个词，这些类是完全不同的：在创建它们时（即，当我们从这些子类创建对象时），它们的父对象的地址（父对象的“this”值）作为隐藏参数传递给它们中的每一个；因此，给他们访问父类的非静态成员的可能性。非常感谢……Nahuel Fouilleul我知道了……如果你不介意，你能说一下我们为什么要在那里使用它吗？…+1删除静态允许
NestedClass。如果InnerClass是静态的，它就不能访问非静态的外部类的成员静态，但如果不是，则至少有一个外部类的实例可以访问，即创建嵌套实例的实例。抱歉，如果不清楚，也许其他人可以解释betterA静态内部类与普通外部类完全相同，只是它的名称隐藏在父类下面。它的唯一目的是允许快速创建类，而不必为每个类创建新文件。没有static这个词，这些类是完全不同的：在创建它们时（即，当我们从这些子类创建对象时），它们的父对象的地址（父对象的“this”值）作为隐藏参数传递给它们中的每一个；因此，允许他们访问父级的非静态成员。