Graphische Benutzeroberfläche in Java mit Swing

Hallo Leute, ich habe am Mittwoch 28. Februar 2018 eine Grafische Anwendung auf java2enterprise.blogspot.de hochgeladen. Natürlich bekam ich zwei Emails welches ich aus Datenschutzgründen nicht hier veröffentlichen werde. In den beiden Mails ging es im allgemeinen über das Programmieren mit dem Fenster also auch Benutzeroberfläche (GUI) gesagt. Natürlich habe ich den beiden recht gegeben und hatte mich entschieden mit meinem Team zusammen uns hinzusetzen und Themen sowie Posts über das Entwickeln beziehungsweise Programmieren mit Benutzeroberflächen in Java beschäftigt. Wir werden also in den nächsten Monaten prinzipiell uns über das Thema GUIs in Java beschäftigen. Dazu möchte ich sagen, dass wir zwischendurch auch paar Anwendungen aus dem Praxis wie die Anwendung namens KontoVerwalten 2.0 veröffentlichen. Dazu müssen wir uns aber bisschen gedulden.

Einführung:

Bevor wir mit den Grundlagen eines GUIs loslegen möchte ich euch erklären, was eine Benutzeroberfläche ist. Wir haben bis Heute nur Programme geschrieben, welches wir in der Konsole ausgeführt haben. Dies war vor ca. 25 Jahren ganz normal. Vor 25 Jahren als die ersten Heimcomputer im Markt kamen wurden sie entweder mit der Hauseigenen IBM-Software, oder mit der MS-DOS von Microsoft mitgeliefert. Jedoch hatten diese Betriebssysteme eine kleine Schwäche. Der Benutzer welches das System bedienen soll, musste sich mit dem auskennen und brauchte davor eine Schulung da man alle Befehle in die Kommandozeile eintippen musste. Heute ist es natürlich einfacher. Wir müssen nur die Mausanzeige (Pfeil) auf das Logo der gewünschten Anwendung bewegen und diese mit Doppelklick starten. Ihr habt es womöglich bemerkt wofür eine Anwendung als Benutzeroberfläche nützlich ist. Genau für die Benutzerfreundlichkeit. Ein Programm welches ich als Konsole Applikation geschrieben habe, muss ich dieses auch in der Konsole aufrufen können. Dafür muss ich die Befehle der Konsole kennen um mit ihr zu arbeiten und den Speicherort der Datei welches ich ausführen möchte.

JFrame:

Ein JFrame ist die Darstellung eines Graphischen Fensters. Die Programmierer sagen meistens Frame oder Fenster dazu und verwenden die Begriffe „JFrame, Benutzeroberfläche, GUI“ selten. Zudem besitzt ein Fenster üblicherweise ein Anwendungsicon und ein Systemmenü. Die Klasse JFrame ist als Top-Level-Container für Graphische Benutzeroberflächen und Applikationen gedacht, die eigenständig auf einem Rechner laufen sollen. In unserem nächsten Beispiel werden wir uns über den Dialogfenster JDialog beschäftigen und dieses mit JFrame vergleichen.

JFrame erzeugen:

In allen Programmiersprachen gibt es eine einzige Faustregel. Diese besagt, dass wenn der Benutzerfreundlichkeit im Vordergrund liegen soll, das Programm sehr Umfangreich und die Arbeit ebenfalls schwer sein wird. Wenn aber die Benutzerfreundlichkeit nicht das A und O des Programms sein soll, so ist das Programmieren oder das Schreiben der Quelldatei nicht allzu schwer. Um einen JFrame manuell zu erzeugen bzw zu konstruieren, muss man nur den entsprechenden Konstruktor aufrufen.

JFrame fenster = new JFrame();

JFrame fenster = new JFrame(“FENSTER“);

Wie ihr es bemerkt habt, haben wir für den Aufruf eines Fensters nur eine Anweisung beziehungsweise ein Objekt mit dem Namen “fenster“ angelegt. Wie das Fenster aussehen soll und welche Funktionen diese dem Benutzer anbieten soll ist voraussichtlich nicht unser Problem. Durch den Aufruf des Konstruktors der Klasse JFrame, legen wir den Titel des Fensters mit der Zeichenkette “FENSTER“ fest. Ich persönlich muss zugeben, dass ich diese Variante, mit dem angeben des Titels, nicht bevorzuge. Meistens fügen wir bei J2E den Titel eines Fensters mit der folgenden Anweisung ein:

Frame.setTitle(“FENSTER“);

Das funktioniert natürlich auch, nachdem der JFrame bereits sichtbar gemacht wurde. Die Methode setTitle(String titel) löst automatisch ein Neuzeichen des Fensters aus.

JFrame sichtbar machen:

Sobald wir eine Klasse mit dem Namen Fenster und eine dazugehörige Main-Methode definiert haben, rufen wir den Konstruktor der Klasse JFrame auf und verpassen dieses Fenster ein Titel. Danach führen dieses aus und was sehen wir? Nanu nicht!!! Warum das? Naja genau das meinte ich vorher mit der Faustregel. Das Programm wird zwar ausgeführt der jedoch im Hintergrund ausgeführt wird. Wir müssen noch die Methode zum zeigen des Fensters, welches wir DAVOR programmiert haben, aufrufen.

setVisible(true);

setVisible(false);

Die Methode setVisible() beschäftigt sich mit der Sichtbarkeit der von uns entworfene Fenster und kann somit nur true oder false Werte des primitiven Datentypen wahrnehmen. Entweder soll das Fenster gezeigt werden oder nicht.

JFrame f = new JFrame();

f.setTitle(“HalloFenster“);

f.setVisible(true);

Größe des Frames Angeben:

Nach dem starten der Anwendung bemerkt ihr sofort, dass das Fenster zwar angezeigt wird jedoch zu klein ist. Obwohl wir die Größe mit dem Mausklick vergrößern oder verkleinern können, müssen wir aber eine angepasste Größe angeben mit dem der Fenster als erstes angezeigt wird. Ihr würdet euch auch nicht wünschen, dass bei jedem Neustart des Browsers ihr die Größe immer Manuel vergrößern sollt.

Die Größe eines JFrames kann man folgendermaßen mit der Methode  setSize(x, y); angeben.

JFrame g = new JFrame();

g.setSize(100, 100);

Die Größe eines des JFrames festlegen zu können müssen wir wie oben die Methode, der Klasse JFrame, setSize(x, y) aufrufen. Dabei sind die x- und y-Werte wie in der zweidimensionalen Analysis als Achsen in X-Richtung (Horizontal) und Y-Richtung (Vertikal) zu betrachten. Der Ursprung O (Orgin) befindet sich jedoch nicht wie in der Mathematik unten links, sondern Oben Links an der Ecke.

Verhalten eines JFrames festlegen:

Wenn man einen JFrame erzeugt, erhält dieser von Haus aus einen gewissen Grad an Benehmen. Das bedeutet jedoch nicht, dass damit die Main-Methode beendet wird. Das kann man gut erkennen, wenn man eine Applikation mit einem JFrame von der Kommandozeile (Terminal, CMD) aus mittels “Java Klassenname“ startet. Auch nachdem man den Frame geschlossen hat, erscheint nicht die den Stopp des Programms anzeigende Zeile mit dem Pfad/Ordner in dem man sich befindet. Um erreichen zu können, dass eine Applikation beim Schließen des Fensters auch wirklich vom Arbeitsspeicher gelöscht wird, so ist die Methode setDefaultCloseOperation() eine Lösung dafür. Anhand diese Methode können wir entscheiden, ob das Programm beim Schließen des Fensters weiter ausgeführt werden soll oder nicht. Hier ein Beispiel:

JFrame frame = new JFrame();

frame.setVisible(true);

frame.setSize(100, 100);

frame.setTitle(“HalloFenster“);

// Standarteinstellung

frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

// Wird beendet sobald das Fenster Geschlossen ist.

// Muss angegeben werden, wenn wir das

// Programm beenden wollen in dem wir das Fenster schließen.

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 

Beim Starten der Entwicklungsumgebung Eclipse könnt ihr den Workspace in Desktop anlegen. Deshalb steht die Datei mit dem Beispielcode direkt nach speichern der Datei im Desktop.

 

Wir gehen auf dem Ordner, die den Namen des Projekts beinhaltet. Danach tippen wir mit der gedrückten Shift-Taste, das ist die Taste mit dem wir die Großbuchstaben eintippen können, auf die Linke Maustaste. Danach erscheint das Menü. Wir gehen dort auf dem Befehl „Eingabeaufforderung hier öffnen“.

 

Danach erscheint das Fenster mit der Eingabeaufforderung am Schirm in dem uns gezeigt wird, in welchem Pfad wir uns befinden. Wie befinden uns im Laufwerk „C“ mit der Benutzername xy, im Desktop, in dem jeweiligen Ordner namens „Hallo“.

Mit dem Befehl „cd“ wechseln wir den Ordner oder den Pfad. Danach geben wir mit der nächsten Aufforderung Programmiersprache, hier natürlich Java, paketName und die KlassenName in dem sich die Main-Methode befindet.

 

In diesem Beispiel war die Anweisung EXIT_ON_CLOSE schon einprogrammiert was bedeutet, dass wir nach dem Schließen des Fensters das Programm beendet wird und wir wieder in unserem Pfad landen. Wodurch wir weitere Angaben tätigen können.

 

Falls wir die Anweisung EXIT_ON_CLOSE nicht eingetragen haben, so wird zwar das Fenster auch geschlossen jedoch nicht das Programm beendet. Das sehen wir, in dem wir nach dem Schließvorgang nicht wieder in unserem Pfad landen. 

 

Hier ist es deutlich sichtbar, dass das Fenster geschlossen ist jedoch die Anwendung vom Speicher noch nicht gelöscht worden ist. Da wir nicht in unserem Pfad gelandet sind. Das bedeutet, dass Betriebssystem verbietet uns jegliche Eingabe da das Programm noch in der Anwendung ist. Ihr könnt es selber versuchen.

Er vergrößert sich automatisch, wenn man auf das entsprechende Maximieren-Symbol klickt und minimiert sich, wenn man auf das minimieren-Symbol klickt. Das kann man kontrollieren, in dem wir die Methode setResizable() aufrufen. Soll das Fenster eine Maximierungs- oder minimierungs-Funktion haben, in dem wir eine Bestimmte Größe haben, muss die Methode setResizable(true) aufgerufen werden. Soll aber das alles dem Benutzer verbieten werden, so muss die Methode als setResizable(false) aufgerufen werden. 

Damit ihr es nachvollziehen könnt und ein Programm zum üben oder tüfteln habt, gibt es Unten ein Beispiel welches ich als Quelldatei auf GitHub >>HIER<< hochgeladen habe.