Optimizing Java code with internal and anonymous classes

Optimizing Java 1.1 simplifies the implementation of some practical structures by modifying the Java language Specification. Among those modifications, the most striking is the internal class and the anonymous class. If used properly, they can make the program easier to understand and maintain. Let's look at how these features work, how to use them correctly, and how to avoid some common mistakes.
Inner class simply put, an "inner class" is a class declared inside another class. Starting with Java 1.1, you can declare another class in one class, which is very similar to declaring fields and methods.    A class that wraps an inner class declaration is called an "external class."     In fact, the Java language Specification also allows you to do more things, including declaring a class in another class or in a socket.     Declare an interface in another interface or in a class.     Declare a class in a method.     Class and interface declarations can be nested to any depth.    Listing A is a blank declaration of classes and interfaces that demonstrates these possibilities. Using an import statement, you can omit package names as you would any other standard class. In addition, in an external class, you can use a simple name to refer to all inner classes and interfaces (see the new statement in listing a).    Note It is still necessary to specify Interface1 from the reference Inner2 in Method1 because Inner2 is at a different level. Table A summarizes the fully qualified names of each of the internal classes and interfaces declared in listing a. After you use the import statement, you can take a shorter form.    Of course, in the outer class, you can also omit the name of the outer class. Name class/interface Inner1 mypackage. Inner1 Interface1 MyPackage. Interface1 Inner2 MyPackage. Interface1.inner2 Interface2 MyPackage. Interface1.interface2 Inner3 Inner3 is local to Method1, so it cannot be accessed outside of the method

One of the most natural applications for referencing inner class internal classes is to declare classes that are used only within another class, or to declare classes that are closely related to another class. As shown in Listing B, it is a simple implementation of a linked list.    Because the node class is typically used only within the scope of the LinkedList, it is a good idea to declare node as an internal class of LinkedList. Access control modifiers that apply to class members also apply to inner classes, that is, inner classes can have package, protected, private, and public access, and their semantics are no different from normal semantics.    Because node is to be used outside of LinkedList, it is declared public. However, the modifier static has different meanings. When applied to an inner class, the class it declares has the same semantics as the other classes, i.e. it can be instantiated and used like a standard class. The only difference is that it has full access to all static members of the external class. Listing c shows a simple program that creates a linked list and prints it to a standard output device.

Non-static Inner class if the inner class does not specify a static modifier, it has full access to all members of the external classes, including instance fields and methods.    To implement this behavior, non-static inner classes store an implicit reference to an instance of an external class. Therefore, a new statement with different syntax is required to instantiate a non-static inner class:. New this form of new statement requires an instance of the outer class so that the inner class can be created in the context of that instance. Note that listing a declares several non-static inner classes and instantiates them in Method1 with the standard new statement. You can do that because METHOD1 is an instance method of an external class, so the new statement is implicitly executed in the context of an instance of an external class.    You need to use the modified syntax only if you instantiate a non-static inner class outside of the outer class or in the context of another object. However, non-static inner classes have some limitations. In particular, they cannot declare static initialization lists and static members unless they are in a constant field. In addition, internal classes declared within a method cannot access local variables and parameters of the method unless they are initialized to final.

    Anonymous classes     Anonymous classes are classes that cannot have names, so there is no way to reference them. They must be declared as part of the new statement when they are created.     this will take another form of the new statement, as follows:     new < class or interface > < class of the main >    This form of the new statement declares an anonymous class that expands on a given class, or implements a given interface. It also creates a new instance of that class and returns it as the result of the statement. The class to extend and the interface to implement are the operands of the new statement, followed by the body of the anonymous class.     If an anonymous class expands on another class, its principal can access the members of the class, the methods that override it, and so on, which is the same as any other standard class. If an anonymous class implements an interface, its principal must implement the method of the interface.     note that the declaration of an anonymous class is done at compile time, and the instantiation occurs at run time. This means that a new statement in the For loop creates several instances of the same anonymous class, rather than creating one instance of several different anonymous classes.     Technically, anonymous classes can be considered non-static internal classes, so they have the same permissions and restrictions as non-static inner classes declared within the method.     if the task to be performed requires an object, but it is not worth creating an entirely new object (either because the required class is too simple or because it is used only within one method), the anonymous class is useful. Anonymous classes are especially good for creating event handlers quickly in swing applications.     List D is a very simple swing application that shows several concepts related to anonymous classes. This example creates two anonymous classes. The first extends the Java.awt.event.WindowAdapter and invokes the application's OnClose method when the application window closes.     even if OnClose is declared private, anonymous classes can call it, because an anonymous class is essentially an internal class of application classes. The second anonymous class implements the Java.awt.ActionListener interface, which closes the application window after a button is pressed. Note the anonymous class can access the local variable frame. This is because anonymous classes are declared inside the same method as the frame. However, the frame is to be declared as fiNAL, otherwise a compilation error will be generated.

The more optimized code internals and anonymous classes are the two great tools that Java 1.1 offers us. They provide better encapsulation, and the result is that the code is easier to understand and maintain, so that the related classes can exist in the same source code file (thanks to the inner class) and avoid a program producing a large number of very small classes (thanks to anonymous classes).