This question already has an answer here: Java inner class and static nested class 23 answers SomeClass.PrioritizedPendingListComparator is a class. You need an instance of it so you have to use new When you define public static class the static means it doesn't implicitly have a reference to the outer class, but you still have to create it in the normal way. One way to avoid new is
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 SomeClass.PrioritizedPendingListComparator是一个类。 你需要一个实例，所以你必须使用new 当你定义public static class ， static意味着它不隐式地引用外部类，但你仍然需要以正常的方式创建它。 避免new一种方法是使用enum 。 public enum PrioritizedPendingListComparator implements Comparator<SomeClass> { INSTANCE; @Override
This question already has an answer here: Java inner class and static nested class 23 answers Because head is an attribute of the LinkedList class Nope, but you're welcome to move the field afterwards Java inner class and static nested class 1) Head is defined outside of the inner class because the inner class does not need a "Head" field, but the outer class does. 2) No
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 因为head是LinkedList类的一个属性 不，但欢迎您随后移动该字段 Java内部类和静态嵌套类 1）Head在内部类的外部定义，因为内部类不需要“Head”字段，但外部类可以。 2）不，它没有。 3）正如评论所说，它被定义为静态的，以便main（）可以访问它。
This question already has an answer here: Java inner class and static nested class 23 answers You can use : A.B.C.D.E e = new A.B.C.D.E();//create an instance of class E e.methodA();//call methodA e.methodB();//call methodB Or like @Andreas mention in comment you can use import ABCDE; , so if your class is in another packager then you can call your class using name_of_package.ABCDE like t
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 您可以使用 ： A.B.C.D.E e = new A.B.C.D.E();//create an instance of class E e.methodA();//call methodA e.methodB();//call methodB 或者像@Andreas在评论中提到你可以使用import ABCDE; ，所以如果你的班级在另一个打包者那里，那么你可以使用name_of_package.ABCDE来调用你的班级： import com.test.A.B.C.D.E; // ^^^^^^^^--------------------
This question already has an answer here: Java inner class and static nested class 23 answers Non static Inner classes are treated as members of outer class. To create their instances, you need to use reference of outer class. So you have to do something like this, OuterClass outer = new OuterClass(); InnerClass inner = outer.new InnerClass(); So, in your case, m obj = new m(); sub1 s1
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 非静态内部类被视为外部类的成员。 要创建它们的实例，你需要使用外部类的引用。 所以你必须这样做， OuterClass outer = new OuterClass(); InnerClass inner = outer.new InnerClass(); 所以，就你而言， m obj = new m(); sub1 s1 = obj.new Sub1();
This question already has an answer here: Java inner class and static nested class 23 answers Instances of static nested classes have no reference to an instance of the nesting class. It's basically the same as putting them in a separate file but having them as nested class is a good choice if the cohesion with the nesting class is high. Non-static nested classsed however require an in
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 静态嵌套类的实例没有引用嵌套类的实例。 它与将它们放在单独的文件中基本相同，但如果嵌套类的内聚性很高，则将它们作为嵌套类是一个不错的选择。 非静态嵌套分类需要创建嵌套类的实例，实例绑定到该实例并有权访问它的字段。 例如，参加这个课程： public class Main{ private String aField = "test"; public static void main(String... args) {
This question already has an answer here: Java inner class and static nested class 23 answers You obviously need an object of OuterClass type: public void someMethod() { OuterClass oc = new OuterClass(); OtherClass.otherMethod(oc); } In case that your inner class is not static, then you could do: //remove static here private class InnerClass { public void someMethod() {
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 你显然需要一个OuterClass类型的对象： public void someMethod() { OuterClass oc = new OuterClass(); OtherClass.otherMethod(oc); } 如果你的内部类不是静态的，那么你可以这样做： //remove static here private class InnerClass { public void someMethod() { OtherClass.otherMethod(OuterClass.this); } } 你应该知道嵌套
This question already has an answer here: Java inner class and static nested class 23 answers A static inner class is associated with the outer class (in this case LinkedStack ) and not to an instance of it. For non-static inner classes, there should be an enclosing instance of the outer class. If Node were not static, it means that for any instance of Node to exist, there must be an instan
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 一个静态的内部类与外部类（在这种情况下是LinkedStack ）相关联，而不是与它的一个实例相关联。 对于非静态内部类，应该有外部类的封闭实例。 如果Node不是静态的，则意味着对于存在的任何Node实例，必须有一个包含该实例的LinkedStack实例。 将Node类作为静态使它更像是一个不绑定到外部类的实例的顶级类。 因此，其他类可以创建Node实例，而无需创建任何
This question already has an answer here: Java inner class and static nested class 23 answers It's calling the constructor of Kb . It's easier to show this in three statements: K.Ka.Kb x1 = new K.Ka.Kb(); K.Ka.Kb.Kc x2 = x1.new Kc(); // Pass x1 as the hidden constructor arg K.Ka.Kb.Kd.Kd k = x2.new Kd(); // Pass x2 as the hidden constructor arg The parentheses you point out actuall
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 它调用Kb的构造函数。 以下三条陈述更容易展示： K.Ka.Kb x1 = new K.Ka.Kb(); K.Ka.Kb.Kc x2 = x1.new Kc(); // Pass x1 as the hidden constructor arg K.Ka.Kb.Kd.Kd k = x2.new Kd(); // Pass x2 as the hidden constructor arg 您指出的括号实际上不适用于Kb而是K.Ka.Kb new K.Ka.Kb() 正在创建K.Ka.Kb嵌套类的新实例。 Kb()是类Kb的默认构造函数。
This question already has an answer here: Java inner class and static nested class 23 answers the way I create a reference for Inner class object is something like accessing static member in Outer class Not at all - since you are using an instance of the Outer to access the constructor of the Inner , this is very much like accessing an instance member of the Outer class, not its static memb
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 我为Inner类对象创建引用的方式就像在Outer类中访问static成员一样 完全没有 - 因为你使用Outer一个实例来访问Inner的构造函数，这就像访问Outer类的实例成员，而不是它的static成员一样。 声明中的Inner类的名称使用外部类Outer的名称进行限定，以避免与顶级类的命名冲突。 原因很容易理解： Inner是一个非静态的内部类，所以它需要引用Outer 。 它隐含地
This question already has an answer here: Java inner class and static nested class 23 answers Try this. Removed the methods for simplicity public class Test1 { public static void main( String [] args) { MyTriangle h1 = new MyTriangle(); } } class MyTriangle implements Triangle{ int side1; int side2; int side3; public MyTriangle(){
这个问题在这里已经有了答案： Java内部类和静态嵌套类23答案 尝试这个。 删除了简单的方法 public class Test1 { public static void main( String [] args) { MyTriangle h1 = new MyTriangle(); } } class MyTriangle implements Triangle{ int side1; int side2; int side3; public MyTriangle(){ this.side1 = 1; this.side2 = 2; this.