Utility Klassen als Werkzeug- & Hilfsklassen in Java Programmen anlegen
Utility Java Klassen – was ist das?
Man nennt diese auch Hilfsklassen von Java.
Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten.
Am Beispiel:
Die Klasse Math ist so eine klassische Utility Klasse.
Wozu braucht man solche Klassen?
Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm.
Hier sind die Methoden enthalten, welche du für Nebenrechnungen oder auch für den Programmablauf benötigst.
Was ist alles nötig für die Umsetzung einer Hilfsklasse?
Drei Dinge benötigt jede Utility-Klasse.
- Die Klasse muss vom kompletten Programm genutzt werden können.
- Außerdem müssen die Methoden und Konstanten für alle Objekte und alle Programmteile gelten.
- Es muss verhindert werden, dass andere Klassen Objekte aus dieser Klasse erzeugen können.
In diesem Beitrag möchte ich dir zeigen, wie du so eine Hilfsklasse anlegst.
Was bietet sich dafür besser an, als ein Tafelwerk.
Ja ein klassisches Tafelwerk ist der Methodenkoffer für ein Mathematikprogramm.
Natürlich kannst du diese Utility-Klassen auch in einem anderen Programm nutzen.
Hier ein paar weitere Beispiele:
- In einem Spiel wird die Zeit des Spielers gemessen und gespeichert.
So eine Methode kann in einer Hilfsklasse liegen und für jedes Nutzer-Objekt zugänglich gemacht werden. - Die Steuerung der Frame-Rate in einem Spiel wird über eine Methode vollzogen.
Auch diese Methode kann in einer Utility Klasse liegen. - Auswertungen von Kursverlusten, Renditen in einem Aktienanalyse-Programm.
Auch hier hilft ein separater Werkzeugkoffer weiter.
Du siehst, die Erstellung einer Java Utility Klasse macht schon Sinn.
Inhalt
So kann die Utility Klasse im kompletten Programm genutzt werden.
Wichtig ist, dass die Klasse nach außen sichtbar ist.
Deshalb muss diese mit dem Access-Modifiers public ausgezeichnet werden.
public class UtilityKlasse {
}
Public bewirkt, dass die Klasse vom kompletten Projekt genutzt werden kann.
So können alle Objekte die Features der Utility Klasse nutzen.
Du brauchst als erstes Konstanten.
- Auch Konstanten sind immer public.
- Außerdem sind Konstanten immer final – somit können die Werte nicht mehr geändert werden.
- Und Konstanten sind objektunabhängig und somit static.
public class UtilityKlasse {
public final static double PI = 3.14159265359;// Kreiszahl
}
Die Methoden müssen ebenfalls statisch sein.
Hier eine Methode, welche den Flächeninhalt eines Kreises berechnet.
public class UtilityKlasse {
public final static double PI = 3.14159265359;// Kreiszahl
static double berechneKreisFlaeche(double radius){
double flaeche= PI*(radius*radius);
return flaeche;
}
}
Zur Erinnerung:
Die Fläche eines Kreis kann mit dem Radius berechnet werden: PI * r².
Was macht die Methode sonst noch?
Die Methode returnt die Fläche vom Datentyp double.
Deshalb wurde hier auch im Kopf der Typ double als Rückgabetyp angegeben.
static double berechneKreisFlaeche()
Das wird noch wichtig, wenn wir die Methode später aufrufen.
Wenn du dir diese Methode so anschaust, erkennst du:
Diese Methode erwartet lediglich Zahlen. Und verrechnet diese.
Aber was ist mit Objekten?
Angenommen du möchtest der Methode einen richtigen Kreis übergeben.
Wie machst du das?
Ganz einfach.
Dann kannst du die Methode überladen und eine zweite Variante dieser Methode anbieten.
public class UtilityKlasse {
public final static double PI = 3.14159265359;// Kreiszahl
//Methode erwartet einen Radius als Zahl
static double berechneKreisFlaeche(double radius){
double flaeche= PI*(radius*radius);
return flaeche;
}
//Methode erwartet ein Kreisobjekt mit einer Instanzvariablen radius
static double berechneKreisFlaeche(Kreis kreisEins){
double flaeche= PI*(kreisEins.radius*kreisEins.radius);
return flaeche;
}
}Jetzt wirst du feststellen, dass Eclipse dir einen Fehler anzeigt.
Das ist auch logisch, denn die Methode erwartet ein Kreisobjekt.
Und bisher haben wir noch keine Kreisklasse.
Bevor du die Methoden der Utility Klasse nutzen kannst, brauchen wir noch einen Kreis.
Also Kreisklasse mit einer Instanzvariablen, namens radius, anlegen.
public class Kreis {
double radius;
//Konstruktor für Kreisobjekt
Kreis(double radius){
this.radius=radius; //Zuweisung der lokalen Variablen zur Instanzvariablen
}
}
Ich biete in dieser Klasse einen Konstruktor an, welche den Radius erwarten.
Somit kann der Nutzer des Programmes beim Erstellen eines Kreisobjektes den Radius gleich übergeben.
Da es sich in der Parameterliste des Konstruktors, um eine lokale Variable handelt – musst du im Rumpf des Konstruktors die Zuweisung mit dem Keywort this erledigen.
Den Kreis beim Programmstart anlegen und Methoden der Utility-Klasse aufrufen
Also brauchst du noch eine Klasse für den Programmstart.
Diese Klasse kannst du nennen, wie du willst.
Hauptsache die main-Methode für den Programmstart ist enthalten.
public class UtilityStart {
/*
* Du kannst diese Klasse nennen, wie du willst.
* Wichtig ist, für den Programmstart -muss diese Klasse die Main-Methode haben
*/
public static void main(String[] args) {
}
}
Und in dieser Klasse kannst du jetzt einen Kreis anlegen.
public class UtilityStart {
public static void main(String[] args) {
Kreis kreisKoerper = new Kreis(20);// Kreis mit Radius von 20
}
}
Und dann kannst du beide Methoden aufrufen und dir die Rückgaben entweder in einer Variable abspeichern.
Oder dir die Rückgaben auf der Konsole sofort ausgeben lassen.
Beginnen wir mit der Methode, welche kein Kreisobjekt benötigt.
Sondern nur die Zahl.
public class UtilityStart {
public static void main(String[] args) {
Kreis kreisKoerper = new Kreis(20);
// Entweder kannst du den Rückgabewert vorher speichern
double flaecheEins = UtilityKlasse.berechneKreisFlaeche(20);
System.out.println(flaecheEins);
// Oder du kannst du den Rückgabewert direkt auf der Konsole ausgeben
System.out.println(UtilityKlasse.berechneKreisFlaeche(20));
}
}
- Falls du den Rückgabewert der Methode zwischenspeichern möchtest, musst du eine lokale Variable vom Datentyp double anlegen.
double flaecheEins = UtilityKlasse.berechneKreisFlaeche(20); - Außerdem kannst du die Methode nicht einfach so aufrufen.
Denn diese befindet sich schließlich in einer anderen Klasse.
In diesem Beispiel hieß die Klasse: UtilityKlasse.
Und deshalb musst du per Punktnotation die Klasse und die Methode direkt ansprechen.
UtilityKlasse.berechneKreisFlaeche(20)
Probier es einmal auf.
Klicke auf „RUN“ und schau dir die Konsolenausgaben an.
Passt oder?
Dann lass uns die andere Methode aufrufen.
Diese erwartet den Kreis als Argument.
public class UtilityStart {
public static void main(String[] args) {
Kreis kreisKoerper = new Kreis(20);
// Entweder kannst du den Rückgabewert vorher speichern
double flaecheEins = UtilityKlasse.berechneKreisFlaeche(20);
System.out.println(flaecheEins);
// Oder du kannst du den Rückgabewert direkt auf der Konsole ausgeben
System.out.println(UtilityKlasse.berechneKreisFlaeche(20));
// Entweder kannst du den Rückgabewert vorher speichern
double flaecheZwei = UtilityKlasse.berechneKreisFlaeche(kreisKoerper);
System.out.println(flaecheZwei);
// Oder du lässt dir den Rückgabewert direkt ausgeben
System.out.println(UtilityKlasse.berechneKreisFlaeche(kreisKoerper));
}
}
Klicke auf „RUN“ und los geht’s.
Du solltest jetzt viermal eine Kreisfläche von 1256.637061436 ausgegeben bekommen.
Bis hierhin läuft es.
Du kannst aber Instanzen der Utility-Klasse anlegen.
Und das ist blöd.
Denn:
- Du brauchst kein Objekt, denn alles in dieser Klasse ist statisch.
- Die Methoden sind zwar für Objekte geeignet. Aber nicht speziell für Objekte der Klasse UtilityKlasse.
- Eine Möglichkeit Objekte aus dieser Klasse zu erstellen, verwirrt dich später vielleicht.
Also lass uns die Instanzierung dieser Klasse unterbinden.
So kannst du das Instanzieren verhindern.
Schau dir nochmal die Utility-Klasse an.
public class UtilityKlasse {
public final static double PI = 3.14159265359;// Kreiszahl
//Methode erwartet einen Radius als Zahl
static double berechneKreisFlaeche(double radius){
double flaeche= PI*(radius*radius);
return flaeche;
}
//Methode erwartet ein Kreisobjekt mit einer Instanzvariablen radius
static double berechneKreisFlaeche(Kreis kreisEins){
double flaeche= PI*(kreisEins.radius*kreisEins.radius);
return flaeche;
}
}
Wir bieten keinen Konstruktor an. Zumindestens nicht explizit.
Klar- Der default Konstruktor ist dennoch immer dabei.
Und mit diesem Default-Konstruktor kann jede andere Klasse Instanzen dieser Klasse erzeugen.
(Wie ich oben im Bild demonstriert habe.)
Und deshalb darfst du den default-Konstruktor nach außen nicht anbieten.
Das heißt, dieser darf nicht sichtbar sein.
public class UtilityKlasse {
public final static double PI = 3.14159265359;
static double berechneKreisFlaeche(double radius){
double flaeche= PI*(radius*radius);
return flaeche;
}
static double berechneKreisFlaeche(Kreis kreisEins){
double flaeche= PI*(kreisEins.radius*kreisEins.radius);
return flaeche;
}
//Durch das Keywort private kann keine Klasse außerhalb auf diesen zugreifen
private UtilityKlasse(){
}
}
Aufgrund dessen, dass der Konstruktor jetzt private ist – verbietet die Klasse die Instanzierung von Objekten.
Der Konstruktor wird nicht mehr nach außen angeboten.
Und ohne Konstruktoraufruf – keine Objekte.
Zusammenfassung:
- Utility Klassen eignen sich besonders gut, um Methoden – welche vom kompletten Programm genutzt werden sollen, anzubieten.
- Wichtig ist dabei, dass diese Klassen keine Objekte erzeugen können.
- Außerdem sollten die angebotenen Methoden und Konstanten dem kompletten Programm und allen Objekten zur Verfügung stehen.
Über den Autor
