CKTIS / Java
Classes et interfaces imbriquées en Java
Distinguez les classes imbriquées statiques des classes internes, exposez les étapes de construction par des interfaces publiques et paramétrez un cache LRU imbriqué.
Version : Java SE 21
Syntaxe
class Outer {
public interface Step { Result build(); }
private static final class Builder implements Step {
public Result build() { return new Result(); }
}
public static final class Result {}
static class LRUCache<K,V> {}
class Inner {}
}
// Where accessible: new Outer.Result() vs. outer.new Inner()Une classe imbriquée statique n’a pas d’instance englobante implicite. Depuis l’extérieur, on la désigne par Outer.Nested et, si le constructeur est accessible, on l’instancie avec new Outer.Nested(). Pour accéder aux membres d’instance d’un objet distinct de la classe englobante, il faut une référence explicite à cet objet. Si la classe imbriquée hérite de la classe englobante, ses méthodes d’instance peuvent accéder aux membres d’instance hérités via leur propre this implicite. En revanche, une classe membre non statique (classe interne) a une instance englobante et peut être instanciée avec outer.new Inner().
Dans static final class, static indique l’absence d’instance englobante et final interdit les sous-classes. Aucun de ces modificateurs ne rend les objets immuables. Dans private static final class Builder, private masque en plus le type d’implémentation au code client situé hors de la classe englobante.
Les interfaces imbriquées sont implicitement static. Une interface membre déclarée dans une classe n’est toutefois pas automatiquement public. Dans l’exemple, les interfaces publiques Main.TitleStep et Main.BuildStep définissent les opérations disponibles. Le type renvoyé par builder() n’expose pas build() ; celui renvoyé par title(...) l’expose.
static class LRUCache<K,V> déclare ses propres paramètres de type : K pour les clés et V pour les valeurs. Elle ne peut pas utiliser les paramètres de type de la classe englobante. L’exemple utilise une LinkedHashMap ordonnée par accès : quand la taille dépasse la limite, pollFirstEntry() supprime l’entrée dont l’accès est le plus ancien. Cette méthode fait partie de l’API Java SE 21 ; le cache de l’exemple n’est pas sûr en cas d’accès concurrents.
Exemples
import java.util.LinkedHashMap;
public class Main {
public interface TitleStep {
BuildStep title(String title);
}
public interface BuildStep {
Report build();
}
public static TitleStep builder() {
return new Builder();
}
private static final class Builder implements TitleStep, BuildStep {
private String title;
@Override
public BuildStep title(String title) {
this.title = title;
return this;
}
@Override
public Report build() {
return new Report(title);
}
}
public static final class Report {
private final String title;
private Report(String title) {
this.title = title;
}
public String title() {
return title;
}
}
static class LRUCache<K,V> {
private final int limit;
private final LinkedHashMap<K,V> entries = new LinkedHashMap<>(16, 0.75f, true);
LRUCache(int limit) {
if (limit < 1) {
throw new IllegalArgumentException("limit must be positive");
}
this.limit = limit;
}
V get(K key) {
return entries.get(key);
}
void put(K key, V value) {
entries.put(key, value);
if (entries.size() > limit) {
entries.pollFirstEntry();
}
}
}
public static void main(String[] args) {
Report report = Main.builder().title("Report").build();
System.out.println(report.title());
Main.LRUCache<String, Integer> cache = new Main.LRUCache<>(2);
cache.put("a", 1);
cache.put("b", 2);
System.out.println(cache.get("a"));
cache.put("c", 3);
System.out.println(cache.get("b"));
}
}Résultat
Report 1 null
Le programme ne crée aucune instance de `Main`. La lecture de `a` renvoie `1` et actualise l’ordre d’accès : l’ajout de `c` évince donc `b`. La lecture suivante de `b` renvoie `null`.
Leçons associées
- Java · Leçon 37 · Intermédiaire · Version : 2
- Java · Leçon 38 · Intermédiaire · Version : 2
- Java · Leçon 40 · Intermédiaire · Version : 2
Sources
- Java Language Specification, Java SE 21 — §8.1.3 Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21 — §8.1.1.2 sealed, non-sealed, and final Classes
- Java Language Specification, Java SE 21 — §8.5 Member Class and Interface Declarations
- Java Language Specification, Java SE 21 — §9.1.1.3 static Interfaces
- Java Language Specification, Java SE 21 — §9.5 Member Class and Interface Declarations
- LinkedHashMap (Java SE 21 & JDK 21)
- SequencedMap (Java SE 21 & JDK 21) — pollFirstEntry()