Anonymous Classes

Notes

　　They make code more consise

　　We declare and instantiate them at the same time

　　They like local classes but don't have a name

　　We use them when we need them only once

 

Declaring Anonymous Classes

　　They are expressions, so we can define the class in another expression, for example.

public class AnonymousClasses {

  interface HelloWorld{
    void greet();
    void greetSomeone(String someone);
  }

  public void sayHello(){

    // declaration of an local class
    class EnglishGreeting implements HelloWorld{
      String name = "world";
      @Override
      public void greet() {
        greetSomeone("world");
      }

      @Override
      public void greetSomeone(String someone) {
        name = someone;
        System.out.println("Hello " + name);
      }
    }

    HelloWorld englishGreeting = new EnglishGreeting();

    // declare and instantiate an anonymous class at the same time
    // in the initialization statements of the local variable
    HelloWorld frenchGreeting = new HelloWorld() {
      String name = "tout le monde";
      @Override
      public void greet() {
        greetSomeone("tout le monde");
      }

      @Override
      public void greetSomeone(String someone) {
        name = someone;
        System.out.println("Salut " + someone);
      }
    }; // do not forget the ;

    englishGreeting.greet(); // Hello world
    frenchGreeting.greetSomeone("Fred"); // Salut Fred
  }

  public static void main(String[] args) {
    new AnonymousClasses().sayHello();
  }
}

 　　

Syntax of Anonymous Classes

　　The new operator

　　The name of an interface to implement or a class to extend

　　Parentheses that contain the arguments to a constructor. Note: interface has no constructor, so use an empty parentheses

　　A body, a class declaration body

　　A semicolon. An anonymous class definition is an expression, which is a part of a statement, so must have a semicolon.

　　

Accessing Local Variables of the Enclosing Scope, and Declaring and Accesssing Members of the Anonymous Class

　　Rules are presented in the following code

public class AnonymousClasses {

  interface HelloWorld{
    void myTest();
  }

  public String author = "yang";
  public static final Integer age = 23;

  public void test(){
    System.out.println("method member of enclosing class");
  };

  public void sayHello(){

    String time = "2020/8/8";
    String sex = "female";

    // declare and instantiate an anonymous class at the same time
    // in the initialization statements of the local variable
    HelloWorld frenchGreeting = new HelloWorld() {

      // can access members of its enclosing class
      String myAuthor = author; // ok
      Integer myAge = age; // ok

      // can access local variables in enclosing scope
      // that are declared final or effectively final
      String myTime = time; // ok

      // shadow the sex variable defined in enclosing scope
      String sex = "male";

      // has the same restrictions as local classes to their members

      // can not declare static methods
//      public static void init(){}

      // can not declare member interfaces
//      interface person{}

      // can have static constant variables
      static final String school = "USTC";

      // Note that you can declare the following
      /**
       * Fields
       * Extra methods
       * Instance initializers
       * Local class
       */
      private Integer money = 100;
      private String city;
      public void extraMethod(){}
      public void instanceInitializers(String city){
        this.city = city;
      }
      class myInnerClass{}
      
      // can not declare constructors

      @Override
      public void myTest(){
        test(); // ok
      }

    }; // do not forget the ;

    frenchGreeting.myTest();
  }
}

 

reference from: https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html