En nestet klasse er en klasse definert inne i en annen klasse. Java har fire typer — statisk nestet, inner (ikke-statisk), lokal, og anonym — hver med forskjellig tilgang til den omsluttende klassen og ulike brukstilfeller.
{
;
{
{
System.out.println(data);
}
}
}
Outer. .Nested();
En static nestet klasse oppfører seg som en toppnivåklasse, men er navnerommet inne i den ytre. Den holder ikke en referanse til en ytre instans — brukt for å gruppere hjelperklasser (f.eks. en Builder, Node i en datastruktur).
public class Outer {
private int value = 5;
class Inner { // non-static → has an implicit reference to Outer
void show() {
System.out.println(value); // can access Outer's INSTANCE members (even private)
}
}
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // needs an Outer instance to create
En ikke-statisk inner klasse holder en implisitt referanse til sin omsluttende instans, så den kan få tilgang til den ytre objektets instansfelter. (Advarsel: denne referansen kan forårsake minnelekkasjer dersom inner-instansen lever lenger enn den ytre.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Sjelden brukt; begrenset til metoden.
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { handleClick(); }
});
Runnable task = new Runnable() {
public void run() { System.out.println("running"); }
};
En anonym klasse er en engangsimplementering av et grensesnitt eller en klasse, definert og instansiert samtidig — historisk vanlig for event-håndterere og callbacks. Moderne Java erstattet ofte disse med lambdaer når målet er et funksjonelt grensesnitt:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Nestede klasser er et nyttig verktøy for å logisk gruppere klasser som kun brukes i en kontekst, noe som øker innkapsling og lesbarhet.
Å forstå typene — spesielt skillet statisk-vs-inner (statisk = uavhengig, inner = holder en referanse til den omsluttende instansen) — betyr noe både for design og for å unngå feil: inner-klassers implisitte ytre referanse kan forårsake minnelekkasjer, og å velge statisk når du ikke trenger den ytre instansen er det renere standardvalget.
Anonyme klasser var den klassiske måten å gi inline-implementeringer (event-håndterere, komparatorer), og å vite at de i stor grad er erstattet av lambdaer for funksjonelle grensesnitt reflekterer moderne Java-kompetanse.
Disse vises gjennom hele standardbiblioteket (f.eks. Map.Entry er et nestet grensesnitt, builders er statiske nestede klasser), noe som gjør dem til praktisk, ofte påtruffet kunnskap.
Et bibliotek av IT-intervjuspørsmål med detaljerte svar — fra Junior til Senior.
Doner