Les classes anonymes (anonymous classes) sont déclarées immédiatement après l'expression d'instanciation d'une classe, permettant directement d'étendre ou d'implémenter respectivement la classe ou l'interface instanciée.

new Classe([Liste d'arguments]) {
  // Instructions de la classe anonyme...
};

new Interface() {
  // Instructions de la classe anonyme...
};

La déclaration d'une classe anonyme doit être toujours suivie d'un point virgule immédiatement après son accolade fermante, sans quoi une erreur de compilation serait générée.

Les classes anonymes obéissent aux mêmes restrictions que les classes locales et de plus, ne peuvent ni être abstraites (abstract) ni être statiques (static).
Par contre, elles portent toujours implicitement le modificateur final.

En fait, aucun modificateur n'est permis dans une déclaration de classe anonyme.

Dans le cas d'une extension, la classe anonyme doit outrepasser une à plusieurs des méthodes de la classe à instancier. La surcharge et la définition d'une nouvelle méthode ne sont pas permis sinon elles provoqueraient une erreur de compilation.

class ClasseExterne {
  static int x = 10;
  static int y = 12;
  public static void main(String[] args){
    Calcul obj = new Calcul() {
      float resultat;
      public float addition(float a, float b) {
        resultat =  a + b;
        System.out.println(resultat);
        return resultat;
      }
      public float soustraction(float a, float b) {
        resultat =  a - b;
        System.out.println(resultat);
        return resultat;
      }
      public float multiplication(float a, float b) {
        resultat =  a * b;
        System.out.println(resultat);
        return resultat;
      }
      public float division(float a, float b) {
        if(b != 0){
        resultat =  a / b;
        System.out.println(resultat);
        return resultat;
        }
        else
        return 0;
      }
    };
    obj.addition(x, y);
    obj.soustraction(x, y);
    obj.multiplication(x, y);
    obj.division(x, y);
  }
}

class Calcul {
  public float addition(float a, float b) {
    return a + b;
  }
  public float soustraction(float a, float b) {
    return a - b;
  }
  public float multiplication(float a, float b) {
    return a * b;
  }
  public float division(float a, float b) {
    return a / b;
  }
}

Dans le cas d'une implémentation, la classe anonyme doit définir chacune des méthodes abstraites de l'interface à instancier, sinon une erreur de compilation se produira.

class ClasseExterne {
  static int x = 10;
  static int y = 12;

  public static void main(String[] args){

    ICalcul obj = new ICalcul() {
      public float addition() {
        resultat = (float)(x + y);
        return (float)(x + y);
      }
      public float soustraction() {
        resultat (float)(x - y);
        System.out.println(resultat);
        return resultat;
      }
      public float multiplication() {
        resultat (float)x * (float)y;
        System.out.println(resultat);
        return resultat;
      }
      public float division() {
        if(y != 0){
          resultat = (float)x / (float)y;
          System.out.println(resultat);
          return resultat;
        }
        else
          return 0;
      }
    };

    obj.addition();
    obj.soustraction();
    obj.multiplication();
    obj.division();
  }
}

interface ICalcul {
  float addition();
  float soustraction();
  float multiplication();
  float division();
}

Une classe anonyme ne peut déclarer explicitement un constructeur, le compilateur Java fournissant automatiquement un constructeur anonyme pour ce genre de classe.

Une classe anonyme ne possède pas d'identificateur et est immédiatement utilisée lors de l'instanciation de la classe ou l'interface concernée.