ZShape is not static so it requires an instance of the outer class. The simplest solution is to make ZShape and any nested class static if you can. I would also make any fields final or static final that you can as well.
You can access the instance of the outer class like this: Outer.this
You need to jump through a few hoops to do this. First, you need to use Class.getConstructor() to find the Constructor object you want to invoke: Returns a Constructor object that reflects the specified public constructor of the class represented by this Class object. The parameterTypes parameter is an array of Class objects that identify … Read more
Make ShowBike.Bicycle static. public class ShowBike { private static class Bicycle { public int gear = 0; public Bicycle(int v) { gear = v; } } public static void main() { Bicycle bike = new Bicycle(5); System.out.println(bike.gear); } } In Java there are two types of nested classes: “Static nested class” and “Inner class”. Without … Read more
Unlike Java, a nested class isn’t a special “inner class” so you’d need to pass a reference. Raymond Chen has an example describing the differences here : C# nested classes are like C++ nested classes, not Java inner classes. Here is an example where the constructor of the nested class is passed the instance of … Read more
No, you can’t, and no, the compiler can’t figure it out. This is why FindBugs always suggests changing anonymous inner classes to named static nested classes if they don’t use their implicit this reference. Edit: Tom Hawtin – tackline says that if the anonymous class is created in a static context (e.g. in the main … Read more
Yes, we can have classes inside interfaces. One example of usage could be public interface Input { public static class KeyEvent { public static final int KEY_DOWN = 0; public static final int KEY_UP = 1; public int type; public int keyCode; public char keyChar; } public static class TouchEvent { public static final int … Read more
I’m using polygenelubricants’s smaller snippet. Remember there’s no concept of nested classes in the bytecode; the bytecode is, however, aware of access modifiers. The problem the compiler is trying to circumvent here is that the method instantiate() needs to create a new instance of PrivateInnerClass. However, OuterClass does not have access to PrivateInnerClass‘s constructor (OuterClass$PrivateInnerClass … Read more
You can never instantiate an interface in java. You can, however, refer to an object that implements an interface by the type of the interface. For example, public interface A { } public class B implements A { } public static void main(String[] args) { A test = new B(); //A test = new A(); … Read more
Nested classes are cool for hiding implementation details. List: class List { public: List(): head(nullptr), tail(nullptr) {} private: class Node { public: int data; Node* next; Node* prev; }; private: Node* head; Node* tail; }; Here I don’t want to expose Node as other people may decide to use the class and that would hinder … Read more