Anonieme klassen in Java
Met een anonieme klasse definieer je een interface-implementatie of een subklasse en maak je er in dezelfde expressie een object van.
CKTIS / Java
Syntax, operatoren en programmeerconcepten. Zoek een uitleg, bekijk een voorbeeld en leer verder.
Met een anonieme klasse definieer je een interface-implementatie of een subklasse en maak je er in dezelfde expressie een object van.
Een array-initialisator maakt een array met waarden tussen accolades. Het aantal elementen bepaalt de lengte van de array.
Declareer en maak arrays, lees en vervang elementen via hun index en houd arraylengte en lijstgrootte uit elkaar. Ontdek wat `new List[2]` maakt en hoe je het ruwe type `List` vermijdt.
Een `.class`-literal geeft het object dat een type vertegenwoordigt. Gebruik het om waarden te filteren, het sleuteltype van een `EnumMap` vast te leggen, een monitor te kiezen of een veldupdater in te stellen.
Een lambda kan een lokale variabele zonder de modifier `final` vastleggen als die effectief finaal is. Een vaste referentie maakt het object waarnaar die verwijst niet onveranderlijk.
In Java SE 21 kan een `enum`-constante argumenten aan de constructor doorgeven en haar gedrag in een eigen class body vastleggen.
Typegrenzen bepalen welke typen je als generieke argumenten kunt gebruiken. Zo behoud je het concrete buildertype, vergelijk je via een supertype en stel je meerdere eisen tegelijk.
Ontdek waarom `Spliterator<String>.tryAdvance` zowel een consumer voor `String` als een consumer voor een supertype zoals `CharSequence` accepteert.
Een hexadecimaal integerliteral geeft een waarde weer in grondtal 16, met het voorvoegsel 0x of 0X. Het achtervoegsel L kiest het type long; zonder achtervoegsel heeft het literal het type int.
Een niet-statische geneste klasse die lid is van een andere klasse is gekoppeld aan een specifiek buitenobject en kan de privévelden ervan lezen.
Schrijf `10000000001L` voor een literal van het type `long`. Zonder achtervoegsel past de waarde niet in `int`, ook niet als de doelvariabele van het type `long` is.
Leer wanneer een literal voor een geheel getal een `int` of `long` is, hoe je grote waarden schrijft en waarom `0L` handig is bij het optellen en omzetten naar `Long`.
`0L` is nul van het type `long`, terwijl `0` van het type `int` is. Dat verschil speelt mee bij overloadselectie, berekeningen en standaardwaarden van het type `Long`.
Een lokale klasse is een benoemde, geneste klasse die bijvoorbeeld in een methodeblok wordt gedeclareerd. Het bereik van haar naam beperkt de levensduur van haar instanties niet.
Met methodoverloading kunnen meerdere methoden dezelfde naam hebben, maar verschillende parameterlijsten gebruiken. De compiler kiest een overload op basis van de argumenten en hun typen tijdens het compileren, niet op basis van de runtimeklassen van de argumentobjecten.
Met de syntaxis `catch (A | B e)` kun je verschillende uitzonderingstypen in één blok afhandelen. De alternatieve typen mogen geen subtype-relatie hebben en parameter `e` is impliciet final.
Leer het verschil tussen statische geneste klassen en innerlijke klassen. Gebruik publieke interfaces voor de stappen van een builder en typeparameters voor een geneste LRU-cache.
De ruwe typen `List` en `ArrayList` omzeilen de controle van het elementtype tijdens compilatie. Toewijzing aan `List<String>` controleert de inhoud niet en haalt geen typeargument terug.
In Java SE 21 valideert of normaliseert de compacte canonieke constructor van een record de argumenten voordat Java hun waarden aan de componentvelden toewijst.
Met `T extends Base<T>` kunnen methoden van de basisklasse een concreet subklassetype teruggeven, zonder dat elke subklasse haar eigen type hoeft op te geven.
Leer Java 21-regex lezen met tekenklassen, kwantoren, groepen, ankers, escape-reeksen en vlaggen die in het patroon staan.
Een blok `static { ... }` voert instructies uit tijdens de initialisatie van een klasse, niet telkens wanneer een object wordt gemaakt. Gebruik het om statische velden voor te bereiden als daarvoor meerdere instructies nodig zijn.
Een statische geneste klasse is lid van een omsluitend type, maar om er een object van te maken heb je geen instantie van dat type nodig.
In Java SE 21 levert een `switch`-expressie een waarde op. Pijlregels voorkomen doorvallen en laten meerdere enumconstanten één `case`-label delen.