Java Anonymous inner class

Anonymous inner class is also an inner class without a name

Because there is no name, the anonymous inner class can only be used once, and it is often used to simplify code writing

But there is also a precondition for using anonymous inner classes: You must inherit from a parent class or implement an interface

Example 1: Do not use anonymous inner classes to implement abstract parties

12345678910111213141516

abstractclassPerson {    publicabstractvoideat();}class Child extendsPerson {    publicvoideat() {        System.out.println("eat something");    }}public classDemo {    publicstaticvoidmain(String[] args) {        Person p = newChild();        p.eat();    }}

running result:eat something

As you can see, we inherit the person class with child, and then we implement an instance of child and transform it upward into a reference to the person class.

However, if the child class here is used only once, wouldn't it be a hassle to write it as a separate class?

The anonymous inner class is introduced at this time.

Example 2: Basic implementation of anonymous inner classes

1234567891011121314

abstractclassPerson {    publicabstractvoideat();}publicclassDemo {    publicstaticvoidmain(String[] args) {        Person p = newPerson() {            publicvoideat() {                System.out.println("eat something");            }        };        p.eat();    }}

running result:eat something

As you can see, we directly implement the methods in the abstract class person in curly braces.

This allows you to omit the writing of a class

Also, anonymous inner classes can be used on interfaces

Example 3: Using an anonymous inner class on an interface

interfacePerson {    publicvoideat();} publicclassDemo {    publicstaticvoidmain(String[] args) {        Person p = newPerson() {            public voideat() {                System.out.println("eat something");            }        };        p.eat();    }}

running result:eat something

As can be seen from the above example, as long as a class is abstract or an interface, the methods in its subclasses can be implemented using anonymous inner classes

The most common situation is in the implementation of multithreading, because to implement multithreading must inherit the thread class or inherit the Runnable interface

An anonymous inner class implementation of the instance 4:thread class

publicclassDemo {    publicstaticvoidmain(String[] args) {        Thread t = newThread() {            publicvoidrun() {                for(inti = 1; i <= 5; i++) {                    System.out.print(i + " ");                }            }        };        t.start();    }}

operating Result:1 2 3 4 5

An anonymous inner class implementation of the instance 5:runnable interface

12345678910111213

publicclassDemo {    publicstaticvoid main(String[] args) {        Runnable r = newRunnable() {            publicvoidrun() {                for(int i = 1; i <= 5; i++) {                    System.out.print(i + " ");                }            }        };        Thread t = newThread(r);        t.start();    }}

operating Result:1 2 3 4 5

Reference: http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html

Java Anonymous inner class