Eine nicht-statische Member-Klasse ist ein Klasse, deren Deklaration direkt von einer äußeren Klasse umschlossen wird. Das folgende kurze Beispiel definiert die Klasse NestedClassExample2, deren Körper neben zwei Methoden auch die nicht-statische Member-Klasse InnerClass enthält. Sie beinhaltet ein nicht-statisches Feld und eine nicht-statische Methode. Die innere Klasse kann keine statischen Felder und keine statischen Methoden deklarieren. Die Verwendung statischer Deklarationen würde der Compiler mit einer Fehlermeldung quittieren ("inner classes cannot have static declarations").

/* NestedClassExample2.java */

public class NestedClassExample2 {
  
  public class InnerClass {
    int b = 4;
        
    public void method2() {
      System.out.println("World!");
    }
  }
  
  public void method1() {
    InnerClass ic = new InnerClass();
    System.out.println(ic.b);
  }
  
  public static void main(String[] args) {
    NestedClassExample2 nce2 = new NestedClassExample2();
    nce2.method1();
    
    NestedClassExample2.InnerClass ic2 = nce2. new InnerClass();
    System.out.println(ic2.b);
    ic2.method2();
  }
}

Die Compilierung von NestedClassExample2.java führt zur Erzeugung der beiden Klassendateien NestedClassExample2.class und NestedClassExample2$InnerClass.class. Nach Ausführen des Beispiels werden auf dem Bildschirm drei Zeilen mit den Inhalten "4", "4", und "World!" ausgegeben. Die erste "4" wird durch den Aufruf von method1 ausgegeben. Innerhalb dieser Methode wird zunächst ein Objekt der inneren Klasse beschafft, damit mit Hilfe der Punktnoation auf das Feld b zugegriffen werden kann. Die zweite ausgegebene "4" beruht auf Anweisungen innerhalb der main-Methode, die erläutert werden sollen: Die Erzeugung von Objekten kann mit Hilfe einer qualifizierten Objekterzeugung erfolgen. Durch diese wird die Möglichkeit geschaffen, Objekte einer inneren Klasse zu generieren. Bei dieser Form der Objekterzeugung wird vor dem Schlüsselwort new ein Primary notiert. Die Abgrenzung zwischen dem Primary und new erfolgt durch einen Punkt. Die Primary-Angabe ist notwendig, da die Erzeugung eines Objekts einer inneren Klasse ein vorhandenes Objekt der äußeren Klasse (im Beispiel nce2) voraussetzt.

Primary. new KlassenName(ArgumentListe_opt)

(Qualifizierte Objekterzeugung (vereinfacht),
"qualified class instance creation expression")

Eine Klasse kann auch innerhalb eines Methodenkörpers deklariert werden. Derartige Klassen werden als lokale Klassen bezeichnet. Die Verwendung der Modifier public, protected, private und static bei der Deklaration einer lokalen Klasse ist nicht zugelassen und würde zu einer Fehlermeldung während der Compilierung führen. Das Beispiel zu lokalen Klassen NestedClassExample3.java deklariert zwei Methoden, wobei innerhalb des Körpers von method1 die lokale Klasse LocalClass deklariert ist.

/* NestedClassExample3.java */

public class NestedClassExample3 {
  
  public void method1() {
    final int b = 4;
    
    class LocalClass {
      int b2 = b;
      public void method2() {
        System.out.println("World!");
      }
    }
    
    LocalClass lc = new LocalClass();
    System.out.println(lc.b2);
    lc.method2();
  }
  
  public static void main(String[] args) {
    NestedClassExample3 nce3 = new NestedClassExample3();
    nce3.method1();
  }
}

Die Abarbeitung des Programms führt zur Ausgabe von "4" und "World!". Das Feld b2 der lokalen Klasse wird mit Hilfe des Feldes b initialisiert. Dies ist nur möglich, da b mit final deklariert wurde. Die lokale Klasse wird innerhalb der Methode method1 genutzt, indem von dieser ein Objekt erzeugt wird.

Die Deklaration einer anonymen Klasse erfolgt durch eine Class-Instance-Creation-Expression. Die Instanzierung und Deklaration der anonymen Klasse erfolgt dadurch in einem Schritt.

Erweiterung der Klasse KlassenName:
    new KlassenName()
    {
      ...
    }

Implementierung des Interfaces InterfaceName:
    new InterfaceName()
    {
      ...
    }

Die zu deklarierende anonyme Klasse (innerhalb des geschweiften Klammerpaares) kann eine vorhandene Klasse erweitern oder ein Interface implementieren. Handelt es sich nach dem Schlüsselwort new um einen Klassennamen, dann wird die entsprechende Klasse durch die zu erstellende anonyme Klasse erweitert. Im zweiten Fall muss die anonyme Klasse das hinter new angegebene Interface implementieren. Das folgende Listing definiert eine Klasse, die später durch eine anonyme Klasse erweitert werden soll:

/* AnonymousSuperClass.java */

public abstract class AnonymousSuperClass {
  int a = 3;
  public abstract int method2();
}

Der Java-Quelltext NestedClassExample4.java verwendet die abstrakte Klasse AnonymousSuperClass. Innerhalb der main-Methode wird method1 aufgerufen, wobei eine Instanz einer anonymen Klasse übergeben wird. Die anonyme Klasse erweitert die abstrakte Klasse AnonymousSuperClass. Dazu wird deren abstakte Methode method2 implmentiert. Zusätzlich wird das Feld b deklariert.

/* NestedClassExample4.java */

public class NestedClassExample4 {
  
  public void method1(AnonymousSuperClass asc) {
    int d = asc.method2();
    System.out.println(d);
  }
  
  public static void main(String[] args) {
    NestedClassExample4 nce4 = new NestedClassExample4();
    nce4.method1(new AnonymousSuperClass() {
                   int b = 4;
                   public int method2() {
                     int c = a * b;
                     return c;
                   }
                 }
                );
  }
}

Der einzige Parameter der Methode method1 ist vom Typ AnonymousSuperClass (die an die Methode übergebene Instanz ist eine Instanz einer Subklasse von AnonymousSuperClass). Innerhalb von method1 wird nun der erhaltene Parameter dazu verwendet, um die Methode method2 der anonymen Klasse aufzurufen. Die Methode gibt den Zahlenwert 12 zurück.