Java 如何在静态方法中实例化非静态内部类？

我有以下代码：

public class MyClass {

   class Inner {
     int s, e, p;
   }

   public static void main(String args[]) {
     Inner in;
   }
}

到目前为止，代码还可以，但我无法在主方法中实例化'in'，如

in=new internal（）

，因为它显示了

非静态字段不能在静态上下文中引用

我可以用什么方法做这件事？我不想使我的
内部
类成为静态的。
您还必须有对其他外部类的引用

Inner inner = new MyClass().new Inner();

如果内部是静态的，那么它将是静态的

Inner inner = new MyClass.Inner();

如果要从方法中创建
new internal（）
，请从类
MyClass
的实例方法中创建：

public void main(){
  Inner inner = new Inner();
}

public static void main(String args[]){
  new MyClass().main();
}

“常规”内部类具有指向外部类实例的隐藏（隐式）指针。这允许编译器生成代码来为您追踪指针，而无需您键入它。例如，如果外部类中有一个变量“a”，那么内部类中的代码只能执行“a=0”，但编译器将生成“outerPointer.a=0”的代码，并将隐藏指针保存在封皮下

这意味着当你创建一个内部类的实例时，你必须有一个外部类的实例来链接它。如果您在外部类的方法中进行创建，那么编译器知道使用“this”作为隐式指针。如果您想链接到其他外部实例，那么可以使用特殊的“new”语法（请参阅下面的代码片段）

如果将内部类设置为“静态”，则不存在隐藏指针，并且内部类不能引用外部类的成员。静态内部类与常规类相同，但其名称的作用域在父类内部

下面是一段代码，演示了创建静态和非静态内部类的语法：

public class MyClass {

    int a,b,c; // Some members for MyClass

    static class InnerOne {
        int s,e,p;
        void clearA() {
            //a = 0;  Can't do this ... no outer pointer
        }
    }

    class InnerTwo {
        //MyClass parentPointer;      Hidden pointer to outer instance
        void clearA() {         
            a = 0;
            //outerPointer.a = 0      The compiler generates this code
        }       
    }

    void myClassMember() {
        // The compiler knows that "this" is the outer reference to give
        // to the new "two" instance.
        InnerTwo two = new InnerTwo(); //same as this.new InnerTwo()
    }

    public static void main(String args[]) {

        MyClass outer = new MyClass();

        InnerTwo x = outer.new InnerTwo(); // Have to set the hidden pointer
        InnerOne y = new InnerOne(); // a "static" inner has no hidden pointer
        InnerOne z = new MyClass.InnerOne(); // In other classes you have to spell out the scope

    }

}

阿列克谢·凯戈罗多夫的答案是正确的。他的解决方案允许您从静态方法中实例化内部类，例如同一类的main（）。否则，不能在静态方法中实例化内部类。它不编译。Alexei的解决方案可以编译，并且允许您从静态方法实例化内部类。其他答案都是有趣的旁注，但我觉得它们对实际问题没有反应

import java.awt.Graphics;
import java.awt.Color;
import javax.swing.JPanel;
import javax.swing.JFrame;

public class Example {
    public class InnerClass extends JPanel {
        public void paint(Graphics g) {
            g.setColor(Color.BLACK);
            g.fillRect(getX(),getY(),getWidth(),getHeight());
            g.setColor(Color.RED);
            g.fillRect(5, 20, 195, 20);
            g.setColor(Color.BLACK);
            g.drawString("This was written by an inner class.", 10, 35);
        }
    }

    public void demonstrate() {
        InnerClass sc = new InnerClass();//<---this is key
        JFrame jf = new JFrame();
        jf.add(sc);
        jf.setSize(220, 130);
        jf.setLocation(450, 450);
        jf.show();
    }

    public static void main(String[] params) {
        Example e = new Example();//<---so is this
        e.demonstrate();//<---and this is also key
    }
}

导入java.awt.Graphics；
导入java.awt.Color；
导入javax.swing.JPanel；
导入javax.swing.JFrame；
公开课范例{
公共类InnerClass扩展了JPanel{
公共空间涂料（图g）{
g、 设置颜色（颜色为黑色）；
g、 fillRect（getX（），getY（），getWidth（），getHeight（））；
g、 setColor（Color.RED）；
g、 fillRect（5,20,195,20）；
g、 设置颜色（颜色为黑色）；
g、 拉丝（“这是一个内部阶级写的。”，10，35）；
}
}
公众假期{
InnerClass sc=new InnerClass（）；//附录：您可以从静态方法中实例化静态内部类。这种代码仅用于从静态方法中实例化非静态内部类。这个答案刚刚改变了我的人生观。outer.new inner（）？甚至从未考虑过这一可能性。对于静态内部，难道你不能简单地执行inner-inner=new-inner（）？@CanLu要为静态嵌套类创建一个对象，请使用
OuterClass.StaticNestedClass nestedObj=new-OuterClass.StaticNestedClass（）
。你的Java知识做得很好。这个标题适合搜索。