This Way of Writing?

Though i have often come across,i dont understand this way of writing code:

Runnable r=new Runnable() {//<----- (braces start 开发者_如何转开发here?)
  public void run() {
    System.out.println("Hello");
  }
};  // ?

What is this? Please explain very clearly.

That's an anonymous inner class. It's creating an implementation of the Runnable interface using code within the braces. As well as implementing interfaces, you can extend other classes. The nice aspects are that you can do this without explicitly creating a separate class, and you can also refer to final local variables (including parameters) within the body of the anonymous inner class.

See the Java tutorial for more details, or just search for "anonymous inner class" for loads of related pages.

As mentioned by others, what is being created here is an anonymous inner class. Specifically, the person who wrote the code is saying:

Instead of an instance of the Runnable class, I want to create a subclass that overrides the "run()" method and create an instance of that. Its not worth my time to create a named subclass, since I'm only going to create this one instance. Instead, just override the method and return the subclass instance I need.

That's an anonymous class declaration - basically, a class that implements the Runnable interface, declared and instantiated inline as an anonymous nested class.

Note that you can also declare anonymous subclasses the same way:

Object o = new Object(){
    public String toString(){ return "boo!" };
}

Also note that you can use variables of the enclosing method inside the anonymous class code, but only if the variables are final (because the anonymous class actually gets a copy of the variable).

I would start with these http://www.google.co.uk/search?q=anonymous+classes+tutorial 23 million results.

Basically, it allows you to define an implementation or a subclass without having to create a fully formed class defintiions.

EDIT: For your own interest, see if you can figure out what this does.

Map<String, String> map = new LinkedHashMap<String, String>() {{ // two brackets
   put("a", "aye");
   put("b", "bee");
   put("c", "see");
   put("d", "dee");
   put("e", "ee");
   put("f", "eff");
}};

It's so called 'anonymous class'.

You can do this:

  class MyRunnable implements Runnable{
     public void run() {
        System.out.println("Hello");
     }
  }

Then:

 Runnable r = new MyRunnable();

And achieve the same thing. However, the MyRunnable class that you created is never needed in any other part of your code. So creating a named class is not necessary. The code that you wrote on the other hand is creating an anonymous inner class such that the implementation of the class is precisely where it is needed. It will not be accessible rom anywhere else in the code but that is the idea, you do not need it anywhere else.