Research, Dev, Share

Anonymous class Java

Posted in Java, Programming Language, Software Development by Khang Vo on June 6, 2010

Some days ago, when answering a question on stackoverflow , I just recognized that I didn’t understand much about anonymous class in Java. Maybe I am not the only one, so I post it here. I think this should be in some book already, but by my bad, I didn’t read it well.

Ok, here is a simple question on stackoverflow:

    public static void main(String[] args) {
        System.out.println(
          new myClass() {
             public String toString() {
               return "myInterfacetoString";
             }
           });

        System.out.println(
          new myClass() {
              public String myFunction() {
                return "myInterfacemyFunction";
                }
          });
    }
and the user asked why the output is:
myInterfacetoString
primitivedemo.Main$2@9304b1

It is extremely easy, right? Because you override the method toString() of the Object class. But then, the questioner asked more: how about change from new myClass() –> new myInterface() with some interface myInterface already declared, what would happen?

My first thought is that the class name of the anonymous class is not necessary and having no relationship with the real class, interface sharing the same name.

But I just remembered about some of my snippet code before with

new Runnable(){

@override

public void run() {}

}

will behave well like a runnable object

So, what is a correct way of anonymous class. After asking Google, I found a good link about it:

http://www.developer.com/java/other/article.php/3300881/The-Essence-of-OOP-using-Java-Anonymous-Classes.htm

There are 2 main important points:

new className(optional argument list){classBody}

This expression instantiates a new object from an unnamed and previously undefined class, which automatically extends the class named className, and which cannot explicitly implement any interfaces. The body of the new class is given by classBody.

The result of executing this expression is that a new class that extends className is defined, a new object of the new class is instantiated, and the expression is replaced by a reference to the new object.

new interfaceName(){classBody}

This expression instantiates a new object from an unnamed and previously undefined class, which automatically implements the interface named interfaceName, and automatically extends the class named Object. The class can explicitly implement one, and only one interface, and cannot extend any class other than Object. Once again, the body of the new class is given by classBody.

Advertisements

2 Responses

Subscribe to comments with RSS.

  1. Khang Vo said, on June 12, 2010 at 11:23 pm

    No, it is even worse comparing to other java’s code:))

  2. Nguyễn Tuấn Anh said, on June 7, 2010 at 12:12 am

    This seems to be an inconsistency in the design of the language :D. Given Java’s verbosity, the following would feel more “natural” 😉
    new interfaceName(…) with implementation {…}
    new className(…) with extension {…}


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: