Description

Anonymous classes in Java are more accurately known as anonymous inner classes. Inner class means that a class is defined inside another class. An anonymous inner class is an inner class that is declared without using a class name at all. That is, of course is why it’s called an anonymous class.

The anonymous inner classes are very useful in some situations. For example, consider a situation where you need to create the only instance of a class, without creating subclasses or performing additional tasks such as method overloading.

Regular usage of inner class in java:

public class OuterClass { // …     public class InnerClass { // … } public static void main(String[] args) {         OuterClass outerObj = new OuterClass(); OuterClass.InnerClass innerObj = outerObj.new InnerClass();     } }

And the usage of the anonymous inner class in Java:

new SomeSuperType().method();

SomeSuperType

Here,  can be an interface, and then this anonymous inner class implements that interface; or it can be a class, and then the anonymous inner class extends that class.

To understand how to define and use such kind of classes, it would be better to walk through an example.

class SomeClass {     public void method() {

System.out.println(“Hello World!”);

}

}

 

public class OuterClass {

public static void main(String[] args) {

new SomeClass() {                       // This is not an instance of SomeClass,              @Override public void method() {    // but an instance of the sub class of SomeClass

System.out.println(“Anonymous Hello World!”);

}

}.method();

}

}

SomeClass

and

OuterClass

. The

SomeClass

In the code above, you can see that we have two classes,  is

main

pretty straightforward — just has a simple method that prints a piece of text. In the  method an anonymous inner class is defined (new SomeClass() { … }) and invoked (new SomeClass() { … }.method();).

1.2  Purpose of Anonymous Inner Class

You have seen now that by creating an anonymous inner class, we create a sub class that extends some super class. But as we can do such thing in the regular style, what is the advantage of using anonymous inner class? Well:

1. First of all, it is faster to just write an anonymous inner class rather than create a new separate class.

final

2. Anonymous inner classes are especially useful when you need and only need one instance of a class, especially such instance is immutable ().
3. We want to avoid creating extra classes without good reasons. The more classes which exist, the more difficult it is to find the one you want!

1.3  Anonymous Inner Classes Implementing Interfaces

The following example shows an anonymous inner class that implements an interface. It is similar with the previous example. Remember this is the typical usage of anonymous inner classes.

interface SomeInterface {     public void method(); } public class OuterClass { public static void main(String[] args) {         new SomeInterface() { @Override public void method() { System.out.println(“Hello World!”); } }.method(); } }

SomeInterface

SomeInterface

In the example, we need a class that implements the  and an instance of such class. What’s more, we only need such instance only once. So we created an instance of an anonymous inner class that implements .

Note this is the only time in Java you can see such syntax: a class implementing an interface without using
the keyword	implements	.

2  Java Reflection

Unlike Python, JavaScript, etc., Java is not a dynamic programming language. It relies heavily on the type of each class/variable. However, dynamically loading classes at runtime is important for object oriented programming. So, is it possible for Java to figure out attributes and methods of some random class? And is it possible to access these attributes, or invoke these methods? The answer is yes — the reflection guarantees such requests. It can:

• recognize any class at runtime;
• construct an instance of any class at runtime;  recognize the attributes and method at runtime;          invoke methods of an instance at runtime.

Here is a quick example — you have used the	SimpleWriter1L	in Lab 1 like this:
import components.simplewriter.SimpleWriter1L; SimpleWriter1L out = new SimpleWriter1L();      // Initialize out.println(“Hello World!”);                    // Invoke out.close();

But to use reflection, you do it like this:

Class<?> simpleWriter1L = Class.forName(“components.simplewriter.SimpleWriter1L”);  // Load Object out = simpleWriter1L.newInstance();                                          // Initialize Method println = simpleWriter1L.getDeclaredMethod(“println”, String.class);         // Invoke println.invoke(out, “Hello World!”); Method close = simpleWriter1L.getDeclaredMethod(“close”); close.invoke(out);

It seems reflection is more complicated, but why do we need it? One of the answers can be found in Deliverable 2. So let’s start do it.

3  Deliverable 1 — Cuboid

Suppose we have an array of cuboids:

Cuboid[] Cuboids = new Cuboid[5];

Cuboid

We want to sort a them: (1) by length; (2) by area; (3) by volume; and lastly (4) by length first and then area. We don’t want to change the  class.

java.util.Arrays.sort

1. For each sorting procedure, sse the method;

java.util.Arrays.sort

method a class that implements

java.util.Comparator

2. Supply each ;

Write and run your code.

DEMO this deliverable to the lab instructor (10 points).

4  Deliverable 2 — Last Call: Fix the Design Pattern

In lab 3, you were presented with a design pattern. While the pattern represented a great idea, our implementation of that idea stunk! Big time!!

AnimalType

Specifically, if you look at the class  … the code sucks!!! It has two massive problems:

1. The conditional structure (Line 29 to Line 34) — this requires to be updated every time a new animal type enters the system (it also needs to be updated if an animal type leaves the code base — yes, those todo’s causing problems again). That is, the conditional structure is inflexible and needs to be removed.

AnimalType

new Lion()

2. needs to know about the animal types — crazy! It needs to know that mice are small — insane!! And it needs to know how to create each animal ( for example) — madness!!!

AnimalType

Rewrite :

1. to avoid using a conditional structure;

AnimalType

2. so it knows NOTHING about the animals it handles. It may still need to accommodate a variable that stores different animal types, but the code in must remain CONSTANT whenever animal types are changed. HINT: think reflection.