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
What you are seeing here is an anonymous inner class: Given the following interface: interface Inter { public String getString(); } You can create something like an instance of it like so: Inter instance = new Inter() { @Override public String getString() { return “HI”; } }; Now, you have an instance of the interface … Read more
Those are the .class files that hold the anonymous inner classes. In your example WelcomeApplet.java contains a top-level class (called WelcomeApplet) and an anonymous inner class, which will be stored in WelcomeApplet$1.class. Note that the exact name of the files holding anonymous inner classes is not standardized and might vary. But in practice I’ve yet … Read more
From JLS 9.8 A functional interface is an interface that has just one abstract method, and thus represents a single function contract. Lambdas require these functional interfaces so are restricted to their single method. Anonymous interfaces still need to be used for implementing multi-method interfaces. addMouseListener(new MouseAdapter() { @Override public void mouseReleased(MouseEvent e) { … … 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
Note, as per the comment, I’d just like to point out that I too recommend using a real type when you need to pass it around the program like this. Anonymous types should only really be used locally in a single method at a time (in my opinion), but anyway, here’s the rest of my … Read more
An anonymous inner class (AIC) can be used to create a subclass of an abstract class or a concrete class. An AIC can also provide a concrete implementation of an interface, including the addition of state (fields). An instance of an AIC can be referred to using this in its method bodies, so further methods … Read more
By an “anonymous class”, I take it you mean anonymous inner class. An anonymous inner class can come useful when making an instance of an object with certain “extras” such as overriding methods, without having to actually subclass a class. I tend to use it as a shortcut for attaching an event listener: button.addActionListener(new ActionListener() … Read more
As noted in comments, some of this becomes irrelevant in Java 8, where final can be implicit. Only an effectively final variable can be used in an anonymous inner class or lambda expression though. It’s basically due to the way Java manages closures. When you create an instance of an anonymous inner class, any variables … Read more