So kannst du das Instanzieren von Java Klassen verhindern, unterbinden
Die Instanzierung von Java Klassen verhindern.
Was heißt das?
Instanzen sind die Objekte einer Java Klasse.
Und Instanzieren oder Instanzierung heißt nichts anderes, als Objekterstellung.
Aber was soll das?
Oder mal anders gefragt:
Wieso sollte man verhindern, dass eine Java Klasse – Objekte erstellen kann?
Schließlich sind doch Objekte der Sinn und Zweck jeder objektorientierten Programmiersprache.
Oder doch nicht?
In diesem Beitrag möchte ich dir zwei Möglichkeiten vorstellen, wie du das Instanzieren von Java Klassen verhindern bzw. verbieten kannst.
Außerdem gehe ich auf das „WARUM“ ein.
Also wann macht es Sinn, Objekte zu erstellen und wann eben nicht.
Lass uns loslegen.
Inhalt
- 1 So werden Instanzen einer Java Klasse erstellt.
- 2 Wann sollte man das Erstellen von Java Objekten einschränken.
- 3 Mit Privaten Konstruktoren kannst du das Erstellen von Objekten verhindern.
- 4 Innerhalb einer Vererbungslinie kannst du das Erstellen von Java Objekten auf bestimmten Stufen verbieten.
- 5 Zusammenfassung:
So werden Instanzen einer Java Klasse erstellt.
Wie legst du Objekte aus bestimmten Java Klassen an?
Na klar, per Konstruktoraufruf.
Dieser Konstruktoraufruf ist somit ein direkter Befehl an das Programm, welcher besagt:
„Jetzt erstell mir ein Java Objekt aus genau dieser Klasse!“
Das Programm bekommt also den Befehl.
Dann schaut sich das Java Programm den Konstruktor an und prüft die Signatur.
Nachdem das Programm den Konstruktor und seine Signatur kennt,
- geht es in die entsprechende Klasse,
- erstellt das Objekt anhand des signaturspezifischen Konstruktors
- und führt den Code im Rumpf des Konstruktors aus.
Am Ende steht ein neues Java Objekt mit allen Instanzvariablen und Instanzmethoden der Klasse.
Ist doch toll, oder?
Aber…..
Wann sollte man das Erstellen von Java Objekten einschränken.
Hier ein Beispiel:
Nehmen wir mal an – Du hast ein Java Programm entwickelt und dieses darf nur von einem User benutzt werden.
Wirklich nur von einem einzigen User.
Also erstelle ich eine Java Klasse, namens „Benutzer“.
Dann könnte die Klasse Benutzer, in etwa so aussehen.
public class Benutzer {
String benutzerName;//Variable welche den Namen der Benutzer speichert
}
Und noch eine Klasse mit main-Methode, um das Programm zu starten.
public class ObjektVerhindernProgramm {
public static void main(String[] args) {
}
}
Wenn du jetzt zum Programmstart, verschiedene Objekte der Benutzer-Klasse anlegst – geht dies ohne Weiteres.
Kein Meckern, kein Klagen – seitens des Programmes.
Und dies ist natürlich blöd.
Denn ab dem zweiten Benutzer muss das Programm, die Objekterstellung verhindern.
Oder es sollte mindestens ein Hinweis erscheinen.
Also, wie könntest du so etwas im Programm umsetzen?
Mit Privaten Konstruktoren kannst du das Erstellen von Objekten verhindern.
Zuerst braucht die Klasse „Benutzer“ einen echten Konstruktor.
Wenn du vor dem Konstruktor das Keywort private einfügst, ist dessen Sichtbarkeit beschränkt.
Und dann ist es anderen Klassen unmöglich – ohne Weiteres – Objekte aus dieser Java Klasse zu erstellen.
So wie hier:
public class Benutzer {
String benutzerName;
private Benutzer(){
}
}
Das Instanzieren von Objekten wird somit komplett verhindert.
Wir wollten es aber bedingt zulassen, oder?
Aber durch etwas Programmlogik, kannst du das Erstellen von Java Objekten dennoch ermöglichen.
Ganz klar – Das Anlegen von Java Objekten muss an Bedingungen geknüpft sein.
Und diese Bedingung lautet:
„Wenn schon ein User existiert, dann keinen zweiten.“
Also brauchst du eine Variable, welche die User zählt.
Da diese nichts mit den Objekten zu tun hat, sollte diese eine Klassenvariable sein.
Falls du den Beitrag, zum „Instanzen-einer-Klasse-zählen“, verpasst hast – klicke später hier.
public class Benutzer {
static int anzahlBenutzer;//Klassenvariable soll die Anzahl zählen und speichern
String benutzerName;
private Benutzer(){
}
}
So nun steht die Variable.
Aber wie machst du jetzt das Objekt?
Auf dem üblichen Weg, mit Konstruktor, geht es nicht.
Diese Brücke haben wir hinter uns zerschlagen.
Da du nicht mehr an den Konstruktor herankommst, muss eine Methode das Java Objekt erstellen.
Diese Methode braucht Bedingungen.
Und Bedingungen setzt du mit if und else Verzweigungen um.
Aber hier erst einmal das Grundgerüst der Methode:
public class Benutzer {
static int anzahlBenutzer;
String benutzerName;
//privater Konstruktor kann von außen nicht aufgerufen werden
private Benutzer(){
}
//Methode zum Erzeugen von Java Objekten
static Benutzer erzeugeInstanz(){
Benutzer neuerBenutzer = new Benutzer();//Erzeugt das Objekt
return neuerBenutzer;//Liefert das Objekt
}
}
Beginnen wir mit der Signatur der Methode.
Im Bild habe ich verschiedene Farben für die drei Bestandteile der Signatur verwendet.
Jetzt lass uns den Methodenrumpf anschauen.
Hier nochmal der Java Code:
public class Benutzer {
static int anzahlBenutzer;
String benutzerName;
//privater Konstruktor kann von außen nicht aufgerufen werden
private Benutzer(){
}
//Methode zum Erzeugen von Java Objekten
static Benutzer erzeugeInstanz(){
Benutzer neuerBenutzer = new Benutzer();//Erzeugt das Objekt
return neuerBenutzer;//Liefert das Objekt
}
}
Im Methodenrumpf wird zuerst ein neues Objekt erstellt.
Als Rückgabewert (Signatur ROT) steht ein „Objekt der Klasse Benutzer“ und deshalb muss die letzte Anweisung – die „return-Anweisung mit Objekt“ sein.
So das Objekt wird angelegt und auch zurückgegeben.
Jetzt fehlt die Programmlogik, welche die Anzahl der bereits angelegten Nutzer prüft.
public class Benutzer {
static int anzahlBenutzer;
String benutzerName;
//privater Konstruktor kann von außen nicht aufgerufen werden
private Benutzer(){
}
//Methode zum Erzeugen von Java Objekten
static Benutzer erzeugeInstanz(){
Benutzer neuerBenutzer = new Benutzer();
if (anzahlBenutzer >= 1){
neuerBenutzer = null;//Zerstörung des Objektes
System.out.println("Zu viele User");
}
else {
System.out.println("Neuer Benutzer angelegt.");
anzahlBenutzer++;//Hochzählen der Variablen
}
return neuerBenutzer;
}
}
Durch den if-Block wird geprüft, ob die Anzahl größer oder gleich 1 ist.
Falls dies der Fall sein sollte, wird das Objekt zerstört.
Und eine Bildschirmausgabe gibt dir die Info, dass zu viele User im Programm sind.
Ansonsten….
Wenn die Anzahl der Nutzer – Null oder Eins ist – startet der else Block.
Und eine Ausgabe bestätigt den neuen Nutzer.
Zum Schluss wird das Objekt zurückgeben.
Dieses neue Objekt kann zwei Zustände haben.
- Entweder zeigt dies auf die Null-Referenz.
Dann wird nach der letzten schließenden Methodenklammer dem Garbage Collector übergeben.
Es ist somit zerstört. - Oder es existiert weiterhin und dient als Rückgabewert der Methode.
Und weiter geht‘s.
Lege doch einmal ein paar Objekte in der Programmstartklasse an.
Aus Überprüfungszwecken kannst du dir auch die Zählvariable zurückgeben lassen.
Doch bedenke:
Statische bzw. Klassenvariablen werden per Punktnotation am Klassennamen aufgerufen.
Klassenmethoden ebenfalls.
public class ObjektVerhindernProgramm {
public static void main(String[] args) {
Benutzer benutzer1 = Benutzer.erzeugeInstanz();//Speichern der Methodenrückgabe als neues Objekt
Benutzer benutzer2 = Benutzer.erzeugeInstanz();//Rückgabe wird in Variable gespeichert
System.out.println(Benutzer.anzahlBenutzer);//Ausgabe der Benutzeranzahl
}
}
Klicke auf „RUN“.
Cool, oder?
Probiere es ruhig einmal selbst aus, ob du der Instanzvariablen – Werte zuweisen kannst.
public class ObjektVerhindernProgramm {
public static void main(String[] args) {
Benutzer benutzer1 = Benutzer.erzeugeInstanz();
Benutzer benutzer2 = Benutzer.erzeugeInstanz();
System.out.println(Benutzer.anzahlBenutzer);
benutzer1.benutzerName="Matze";//erster Benutzer namens Matze
System.out.println(benutzer1.benutzerName);//Überprüfung
}
}
Klicke nochmal auf „RUN“.
Und läuft?
Mach es einmal beim zweiten Benutzer-Objekt.
Es kommt natürlich zu einer Null-Pointer-Exception, da ab dem zweiten Benutzer – die Variable ins Nullfeld bzw. ins Nichts verweist.
Mit Try und catch Blöcken, könntest du diese Ausnahmen behandeln.
Ich steige auf dieses Thema jetzt ab nicht weiter ein.
Stattdessen möchte ich eine Etage tiefer gehen.
Bei der Vererbung gibt es Probleme mit privaten Konstruktoren.
Denn die erweiterten Klassen müssen dann auf den Konstruktor der Superklasse zugreifen.
Hier am Beispiel der Kindklasse „BenutzerWeiblich“.
public class BenutzerWeiblich extends Benutzer{
BenutzerWeiblich (){
super();//vergeblicher Aufruf des Superkonstruktors der Elternklasse
}
}
Die Klasse „BenutzerWeiblich“ erweitert die Klasse „Benutzer“.
Um ein Objekt der Klasse „BenutzerWeiblich“ anzulegen, muss der Konstruktor per „Super-Keywort“ auf den Konstruktor der Vaterklasse zugreifen.
Da der Konstruktor der Vaterklasse, aber private ist – geht dies nicht.
Somit solltest du private Konstruktoren nur verwenden, wenn du sicher bist – dass du die Klasse niemals erweitern wirst.
Die Klasse darf somit keine Kindklassen haben, welche von ihnen erben.
- Verwende private Konstruktoren um die Instanzierung von Java Klassen – komplett, teilweise oder bedingt zu verbieten.
- Verwende private Konstruktoren aber nicht, falls zur Java Klasse, weitere Kindklassen existieren – von denen Objekte erstellt werden müssen.
Aber…
Es gibt noch eine weitere Möglichkeit das Erstellen von Java Objekten zu verhindern.
Und diese Variante eignet sich eindeutig besser im Zusammenhang mit Vererbung.
Innerhalb einer Vererbungslinie kannst du das Erstellen von Java Objekten auf bestimmten Stufen verbieten.
Schau mal dieses Bild an.
Diese Vererbungslinie stammt aus einem früheren Beitrag.
Hier nochmal ganz kurz, worum es geht.
- Die Superklasse „Lebewesen“ besitzt alle Eigenschaften und Methoden, welche für Lebewesen zutreffen.
Also all das, was Menschen, Tiere oder Pflanzen gemeinsam haben. - Die Kinderklassen erweitern die Superklasse um eigene spezifische Methoden.
Jetzt mal ganz ehrlich….
Ist es nötig Lebewesen-Objekte zu erstellen?
Hast du schon einmal von Frauen gehört, welche im Kreissaal so eine Antwort bekamen?
Also ich nicht.
Und genauso ist es in der Javawelt.
Es macht oft keinen Sinn – Lebewesen zu erstellen.
Du erstellst stattdessen, Menschen oder besser noch Mädchen und Jungen.
Somit müsste die Instanzierung für die Lebewesenklasse verboten werden.
Das Instanzieren kannst du mit dem Java Keywort abstract verbieten.
Indem du eine Klasse abstract machst, gilt diese als abstrakt oder allgemein.
Und zwar ist diese so allgemein, dass eine Objekterstellung unnötig ist.
Hier am Beispiel der Lebewesenklasse:
abstract public class Lebewesen {
int groesse;
}
Und jetzt ist es dir nicht möglich Objekte dieser Klasse anzulegen.
public class ObjektVerhindernProgramm {
public static void main(String[] args) {
Lebewesen ueberraschung = new Lebewesen();//Klasse abstract - Es kann kein Objekt angelegt werden
}
}
Aber die Klasse Mensch könnte von der Klasse Lebewesen erben.
Und sie ist nicht abstract.
public class Mensch extends Lebewesen {
}
Und jetzt kannst du Mensch-Objekte anlegen und Lebewesen, nach wie vor, nicht.
Du kannst das Instanzieren von Java Klassen auf bestimmten Ebenen verbieten.
Angenommen eine Klasse Frau erbt von Mensch.
Und Frau wäre wieder abstract.
- Dann kannst du keine Lebewesen erzeugen.
- Du kannst dann Menschen erzeugen, welche hierarchisch unter Lebewesen liegen.
- Und du kannst wiederum keine Frauen Objekte anlegen, welche von Menschen erben.
Somit bist du mit abstrakten Klassen extrem flexibel, was dein Klassen- und Vererbungsdesign angeht.
Nicht schlecht, oder?
Zusammenfassung:
- Das Instanzieren von Java Klassen kannst du auf zwei verschiedenen Wegen verhindern.
- Zum Einen kannst du das Anlegen von Java Objekten verhindern, indem du private Konstruktoren anbietest.
Dabei solltest du darauf achten, dass keine Kindklassen zur „privaten-Konstruktoren-Klasse“ existieren.
Mit etwas Code kannst du nur bestimmte Objekte zulassen und somit die Instanzierung steuern und kontrollieren. - Mit dem Java Keywort abstract kannst du Java Klassen als abstrakt bzw. allgemein kennzeichnen.
Von diesen Klassen können dann ebenfalls keine Objekte erstellt werden.
Aber im Unterschied zu privaten-Konstruktoren-Methode vererbt sich die „Nicht-Instanzierung“ nicht.
Über den Autor
