Une classe locale est définie à l'intérieur d'une méthode, et partant, agît librement et essentiellement au sein de cette dernière.

modificateur class UneClasse {
  modificateur type_retour uneMethode([Liste de paramètres]){
    class UneClasseLocale {
      // instructions...
    }
  }
}

Il n'est possible de déclarer des classes locales, dont la portée est limitée au bloc, qu'avec les modificateurs final ou abstract. Les modificateurs suivants : public, protected, private et static, sont interdits.

Les données membres d'une classe externe peuvent être accédés par la classe locale.

class ClasseExterne {
  int x = 10;
  int y = 12;
  int z = x + y;
  void addition(){
    class ClasseLocale {
      boolean verification(){
        if(x + y == z)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
    if(obj_in.verification()){
      x = x + y;
      System.out.println("La classe interne a bien accédé aux "
                          + "membres de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "nz = " + z);
     }
     else 
       System.out.println("Erreur !");

   }
   public static void main(String[] args){
     ClasseExterne obj_out = new ClasseExterne();
     obj_out.addition();
  }
}

Seules les variables locales et les paramètres de la méthode d'inclusion, déclarées avec le modificateur final, peuvent être exploitées par les classes internes locales, sinon une erreur se produit lors de la compilation. De plus, ces variables doivent être impérativement assignées avant leur emploi dans la classe locale.

class ClasseExterne {
  int x = 10;
  int y = 12;
  // Paramètre constant utilisable par la classe locale
  ClasseExterne(final int p){
    // Constante utilisable par la classe locale
    final int a = 20;
    // Variable inutilisable par la classe locale
    int b = 44;
    class ClasseLocale {
      boolean verification(){
        if(x + y == a + p)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
      if(obj_in.verification()){
        x = x + y;
        System.out.println("La classe interne a bien accédé aux "
                          + "membres de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "na = " + a);
      }
      else 
        System.out.println("Erreur !");
  }
  public static void main(String[] args){
    ClasseExterne obj_out = new ClasseExterne(2);
  }
}

Lorsqu'une classe locale est déclarée dans une méthode statique, alors les variables d'instances de la classe externe ne sont plus accessibles pour la classe imbriquée.

class ClasseExterne {
  static int x = 10;
  static int y = 12;
  static int z = x + y;
  static void addition(){
    class ClasseLocale {
      boolean verification(){
        if(x + y == z)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
    if(obj_in.verification()){
      x = x + y;
      System.out.println("La classe interne a bien accédé aux "
                          + "membres statiques de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "nz = " + z);
     }
     else 
       System.out.println("Erreur !");

    }
    public static void main(String[] args){
    addition();
  }
}

Seules, les variables statiques de la classe externe peuvent être exploitées par la classe localisée dans la méthode statique.

L'utilisation d'une classe locale ne dépend pas de l'instanciation d'une classe externe, contrairement aux classes internes simples. Autrement dit, il n'est donc pas utile d'instancier d'abord la classe externe pour instancier ensuite la classe locale.