[Java] Nested class

Nested Class

• ** Nested Class **
• ** static member class **
• ** Inner Class **
• ** Non-static member class **
• ** Anonymous class **

static member class

• Class (MyHelper) depends on a specific class (MyClass), MyHelper can only be called from MyClass
• → Consider combining them into one .java file
• ** Top level class **: Class directly under the non-nested file
• ** Enclosing class **: Class with nested classes inside
• Parent class X: Enclosing class and top level class
• Child class Y: Z's enclosing class and X's nested class
• Grandchild class Z: Y nested class

public class MyClass{...}
class MyHelper{...}

• However, MyHelper is ** package private ** and can be freely accessed from the same package.
• → ** static should be MyClass private! ** **
• If you define a nested class under the class block of the enclosing class
• ** Nested classes are not visible outside the enclosing class **
• The name of the nested class is ** Enclosing Class.Nested Class (MyClass.MyHelper) **
• Can be called by member class name inside the enclosing
• import (package name) .MyClass.MyHelper;
  can be used from outside the enclosing
  var h = new MyHelper ();

//MyHelper definition under class block
public class MyClass {
  //Definition of static member class
  //Members cannot be seen from outside My Class
  private static class MyHelper {
    public void show() {
      System.out.println("Nested class is running!");
    }
  }
  public void run() {
    //MyHelper can be called inside the enclosing
    var helper = new MyHelper();
    helper.show();
  }
}

public class NestBasic {
  public static void main(String[] args) {
    var c = new MyClass();
    c.run();
    //MyHelpe is invisible from outside MyClass
    // var h = new MyClass.MyHelper(); //error!
  }
}

Non-static member class (= inner class)

• No static modifier
• ** Inner class **: Belongs to the enclosing object
• ** static member class **: belongs to enclosing class
• Features of inner class
• Requires an enclosing object to instantiate an inner class **
• From the inner class ** Access the enclosing class member via this variable **
• ** Used for instance field reference of enclosing class **
• Consume memory as each instance has a reference to the enclosing object

class MyClass {
  private String str1 = "Enclosing instance";
  private static String str2 = "Enclosing class";

  private class MyHelper {
    private String str1 = "Nested instance";
    private static final String str2 = "Nested class";

    public void show() {
      //Inner class has a reference to the enclosing object
      //MyClass.Accessable with this
      System.out.println(MyClass.this.str1); //Enclosing instance
      System.out.println(MyClass.str2); //Enclosing class
    }
  }

  public void run() {
    //An instance of the inner class is created by the instance method of the enclosing class.
    var helper = new MyHelper();
    helper.show();
    //Access inner class from enclosing object
    System.out.println(helper.str1); //Nested instance
    System.out.println(MyHelper.str2); //Nested class
  }
}

public class NestedAccess {
  public static void main(String[] args) {
    var c = new MyClass();
    c.run();
  }
}

Example of non-static member class (inner class)

• If you declare a private inner class, you cannot see it from outside the enclosing
• Only the type name is invisible **, instance reference is unlimited

java:java.util.AbstractList.java

package java.util;
import java.util.function.Consumer;
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
//...Omission

    /*Iterators
No need to show the internal implementation of the Itr class
It would be nice if the Iterators type, which is the implementation source, could be seen from the outside.
The return value of the iterator method is an Iterator type
    */
    public Iterator<E> iterator() {
        return new Itr();
    }
//...Omission

    /*Inner class
Implement an iterator that accesses the private field in the list and accesses the subordinate elements in order
Iterator is defined separately as an Iterator implementation class
    */
    private class Itr implements Iterator<E> {
//...Omission
    }
//...Omission
}

Anonymous class (anonymous class)

• ** Used as a container to represent specific processes collectively **
• ex: Event listener
• Not reused elsewhere as it is strongly related to a particular context (such as user behavior)
• ** new base class (argument, ...) {class body} **
  • new View.OnClickListener(){
• Since the anonymous class has no name, specify the name of the base class / interface in the new operator.
• You can pass it to the method as it is to the prepared listener instance
• Note;
• I can't have a constructor (initialization is OK)
• Not inheritable (implicitly final)
• Abstract class cannot be declared

//Event listener registration
btn.setOnClickListener(
  //Anonymous class(Event listener)Definition
  new View.OnClickListener(){
    //btn Click to display current time in txt
    @Override
    public void onClick(View view){
      TextView txt = findViewById(R.id.txtResult);
      txt.setText(LocalDateTime.now().toString());
    }
  }
);

Local class

• Methods, constructors, etc. ** Classes defined under blocks **
• Used when a class is used in a specific method or constructor
• Anonymous class can be used as a substitute