Local Classes

Notes:

　　Local classes are classes that are defined in a block.

　　We typically find local classes defined in the body of a method.

Declaring Local Classes:

public class LocalClassExample {

  static String regularExpression = "[^0-9]";

  public static void validatePhoneNumber(
      String phoneNumber1, String phoneNumber2){

    int numberLength = 10;
    // Local Class
    class PhoneNumber{

      String formattedPhoneNumber = null;

      PhoneNumber(String phoneNumber){
        // numberLength = 7; compiler error, the value of this variable cannot be changed
        String currentNumber = phoneNumber.replaceAll(
            regularExpression, "");
        if (currentNumber.length() == numberLength)
          formattedPhoneNumber = currentNumber;
      }

      public String getNumber(){
        return formattedPhoneNumber;
      }
    }

    PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
    PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);

    if (myNumber1.getNumber() == null)
      System.out.println("First number is invalid");
    else
      System.out.println("First number is " + myNumber1.getNumber());

    if (myNumber2.getNumber() == null)
      System.out.println("Second number is invalid");
    else
      System.out.println("Second number is " + myNumber2.getNumber());
  }

  public static void main(String[] args) {
    validatePhoneNumber("123-456-7890", "456-7890");
  }

}

Accessing Members of an Enclosing Class

　　A local class can access its enclosing class's members, in this example, such as the member LoacalClassExample.regularExpression.

　　A local class also can access its enclosing method's local variable, which must not be changed by local class, such as the numberLength.

　　A local class also can access its enclosing method's paremeters, such as the phoneNumber1 and phoneNumber2.

Shadowing and Local Classes

　　The declarations of a variable in local class shadow declarations in the enclosing scope that have the same name.

public class ShadowTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            System.out.println("x = " + x); // 23
            System.out.println("this.x = " + this.x); // 1
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x); // 0
        }
    }

    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

Serialization

　　Serialization of inner classes, including local and anonymous classes, is strongly discouraged. 

Local Classes Are Similar To Inner Classes

　　They cannot define or declare any static members.

 　　You cannot declare an interface inside a block（such as method）; interfaces are inherently static.

public void greetInEnglish() {
    interface HelloThere { // not compile
      public void greet();
    }
    class EnglishHelloThere implements HelloThere {
      public void greet() {
        System.out.println("Hello " + name);
      }
    }
    HelloThere myGreeting = new EnglishHelloThere();
    myGreeting.greet();
  }

　　You cannot declare static initializers or member interfaces in a local class.

public void sayGoodbyeInEnglish() {
   class EnglishGoodbye {
       public static void sayGoodbye() { // not compile
           System.out.println("Bye bye");
       }
   }
   EnglishGoodbye.sayGoodbye();
8 }

　　A local class can have static members provided that they are constant variables. 

public void sayGoodbyeInEnglish() {
    class EnglishGoodbye {
      public static final String farewell = "Bye bye"; // ok
      public void sayGoodbye() {
        System.out.println(farewell);
      }
    }
    EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
    myEnglishGoodbye.sayGoodbye();
  }

reference from: 

　　https://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html

　　https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html#shadowing