class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}
- Niet-statische geneste klassen. Dit worden ook wel innerlijke klassen genoemd.
- Statische geneste klassen.
- een lokale klas
- een anonieme klas
In de les van vandaag bespreken we interne klassen (ook wel niet-statische geneste klassen genoemd). Ze zijn speciaal gemarkeerd in het algemene diagram, zodat u niet verdwaalt :) Laten we beginnen met de voor de hand liggende vraag: waarom worden ze "innerlijke" klassen genoemd? Het antwoord is vrij eenvoudig: omdat ze in andere klassen worden gemaakt. Hier is een voorbeeld:
public class Bicycle {
private String model;
private int weight;
public Bicycle(String model, int weight) {
this.model = model;
this.weight = weight;
}
public void start() {
System.out.println("Let's go!");
}
public class Handlebar {
public void right() {
System.out.println("Steer right!");
}
public void left() {
System.out.println("Steer left!");
}
}
public class Seat {
public void up() {
System.out.println("Seat up!");
}
public void down() {
System.out.println("Seat down!");
}
}
}
Bicycleklas. Het heeft 2 velden en 1 methode: start(). 
Het verschilt van een gewone klasse doordat het twee klassen bevat: Handlebaren Seat. Hun code is in de klas geschreven Bicycle. Dit zijn volwaardige klassen: zoals u kunt zien, heeft elk van hen zijn eigen methoden. Op dit punt heb je misschien een vraag: waarom zouden we in vredesnaam de ene klas in de andere plaatsen? Waarom zouden ze innerlijke klassen maken? Stel dat we aparte lessen nodig hebben voor de concepten stuur en zadel in ons programma. Het is natuurlijk niet nodig dat we ze genest maken! We kunnen gewone klassen maken. Bijvoorbeeld als volgt:
public class Handlebar {
public void right() {
System.out.println("Steer right!");
}
public void left() {
System.out.println("Steer left");
}
}
public class Seat {
public void up() {
System.out.println("Seat up!");
}
public void down() {
System.out.println("Seat down!");
}
}
public class Main {
public static void main(String[] args) {
Handlebar handlebar = new Handlebar();
handlebar.right();
}
}
public class Main {
public static void main(String[] args) {
Bicycle peugeot = new Bicycle("Peugeot", 120);
Bicycle.Handlebar handlebar = peugeot.new Handlebar();
Bicycle.Seat seat = peugeot.new Seat();
seat.up();
peugeot.start();
handlebar.left();
handlebar.right();
}
}
Seat up!
Let's go!
Steer left!
Steer right!
In deze situatie zal onze vorige oplossing niet werken. In een fietsenwinkel is elk afzonderlijk fietsonderdeel zinvol, ook los van een fiets. We hebben bijvoorbeeld methoden nodig zoals "pedalen verkopen aan een klant", "een nieuw zadel kopen", enz. Het zou een vergissing zijn om hier interne klassen te gebruiken - elk afzonderlijk fietsonderdeel in ons nieuwe programma heeft een betekenis die op zijn eigen: het kan worden gescheiden van het concept van een fiets. Dit is precies waar u op moet letten als u zich afvraagt of u interne klassen moet gebruiken of alle entiteiten als afzonderlijke klassen moet organiseren. Objectgeoriënteerd programmeren is goed omdat het het gemakkelijk maakt om echte entiteiten te modelleren. Dit kan uw leidraad zijn bij het beslissen of u innerlijke klassen wilt gebruiken. In een echte winkel reserveonderdelen zijn gescheiden van fietsen - dit is oké. Dit betekent dat het ook goed is bij het ontwerpen van een programma. Oké, we hebben de "filosofie" bedacht :) Laten we nu eens kennis maken met belangrijke "technische" kenmerken van innerlijke klassen. Dit is wat u absoluut moet onthouden en begrijpen:
-
Een object van een binnenklasse kan niet bestaan zonder een object van een buitenklasse.
Dit is logisch: daarom hebben we de
SeatenHandlebarinnerlijke klassen in ons programma opgenomen - zodat we niet eindigen met verweesde sturen en stoelen.Deze code compileert niet:
public static void main(String[] args) { Handlebar handlebar = new Handlebar(); }Hieruit volgt nog een belangrijk kenmerk:
-
Een object van een binnenklasse heeft toegang tot de variabelen van de buitenklasse.
Laten we bijvoorbeeld een
int seatPostDiametervariabele (die de diameter van de zadelpen vertegenwoordigt) aan onzeBicycleklas toevoegen.Vervolgens
Seatkunnen we in de innerlijke klasse eendisplaySeatProperties()methode maken die de stoeleigenschappen weergeeft:public class Bicycle { private String model; private int weight; private int seatPostDiameter; public Bicycle(String model, int weight, int seatPostDiameter) { this.model = model; this.weight = weight; this.seatPostDiameter = seatPostDiameter; } public void start() { System.out.println("Let's go!"); } public class Seat { public void up() { System.out.println("Seat up!"); } public void down() { System.out.println("Seat down!"); } public void displaySeatProperties() { System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter); } } }En nu kunnen we deze informatie weergeven in ons programma:
public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); Bicycle.Seat seat = bicycle.new Seat(); seat.displaySeatProperties(); } }Console-uitvoer:
Seat properties: seatpost diameter = 40Opmerking:de nieuwe variabele wordt gedeclareerd met de strengste toegangsmodificator (
private). En toch heeft de binnenklas toegang! -
Een object van een binnenklasse kan niet worden gemaakt in een statische methode van een buitenklasse.
Dit wordt verklaard door de specifieke kenmerken van hoe innerlijke klassen zijn georganiseerd. Een binnenklasse kan constructors met parameters hebben, of alleen de standaardconstructor. Maar hoe dan ook, wanneer we een object van een binnenste klasse creëren, wordt een verwijzing naar het object van de buitenste klasse onzichtbaar doorgegeven aan het gecreëerde object van de binnenste klasse. De aanwezigheid van zo'n objectreferentie is immers een absolute vereiste. Anders kunnen we geen objecten van de innerlijke klasse maken.
Maar als een methode van de buitenste klasse statisch is, dan hebben we misschien geen object van de buitenste klasse! En dit zou een schending zijn van de logica van hoe een innerlijke klasse werkt. In deze situatie genereert de compiler een fout:
public static Seat createSeat() { // Bicycle.this cannot be referenced from a static context return new Seat(); } -
Een binnenklasse kan geen statische variabelen en methoden bevatten.
De logica is hetzelfde: statische methoden en variabelen kunnen bestaan en kunnen worden aangeroepen of waarnaar wordt verwezen, zelfs als er geen object is.
Maar zonder een object van de buitenste klasse hebben we geen toegang tot de binnenste klasse.
Een duidelijke tegenstelling! Dit is de reden waarom statische variabelen en methoden niet zijn toegestaan in innerlijke klassen.
De compiler genereert een foutmelding als u ze probeert te maken:
public class Bicycle { private int weight; public class Seat { // An inner class cannot have static declarations public static void displaySeatProperties() { System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter); } } } -
Bij het maken van een object van een innerlijke klasse is de toegangsmodificator belangrijk.
Een binnenklasse kan worden gemarkeerd met de standaard toegangsmodificaties:
public,private,protected, enpackage private.Waarom is dit van belang?
Dit beïnvloedt waar we instanties van de innerlijke klasse in ons programma kunnen maken.
Als onze
Seatklasse is gedeclareerd alspublic, kunnen weSeatobjecten in elke andere klasse maken. De enige vereiste is dat er ook een object van de buitenste klasse moet bestaan.Dat hebben we hier trouwens al gedaan:
public class Main { public static void main(String[] args) { Bicycle peugeot = new Bicycle("Peugeot", 120); Bicycle.Handlebar handlebar = peugeot.new Handlebar(); Bicycle.Seat seat = peugeot.new Seat(); seat.up(); peugeot.start(); handlebar.left(); handlebar.right(); } }We kregen gemakkelijk toegang tot de
Handlebarbinnenste klas van deMainklas.Als we de innerlijke klasse declareren als
private, kunnen we alleen objecten maken binnen de buitenste klasse.SeatWe kunnen niet langer een object "aan de buitenkant" maken :private class Seat { // Methods } public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); // Bicycle.Seat has private access in Bicycle Bicycle.Seat seat = bicycle.new Seat(); } }Je begrijpt de logica waarschijnlijk al :)
-
Toegangsmodificatoren voor interne klassen werken hetzelfde als voor gewone variabelen.
De
protectedmodifier geeft toegang tot een instantievariabele in subklassen en klassen die zich in hetzelfde pakket bevinden.protectedwerkt ook voor innerlijke klassen. We kunnenprotectedobjecten van de innerlijke klasse maken:- in de buitenste klasse;
- in zijn subklassen;
- in lessen die in hetzelfde pakket zitten.
Als de binnenklasse geen toegangsmodificator (
package private) heeft, kunnen objecten van de binnenklasse worden gemaakt:- in de buitenste klasse;
- in lessen die in hetzelfde pakket zitten.
U bent al lang bekend met modifiers, dus geen problemen hier.
GO TO FULL VERSION