Trinkgeldrechner App – Java Tutorial für Anfänger

Warst du schon immer schlecht im Kopfrechnen oder einfach zu träge zum Kopfrechnen? Gerade bei einem Restaurantbesuch wäre es praktisch, wenn du eine App hättest, die ein passendes Trinkgeld für deinen Kellner ausrechnen kann. In diesem Java-Tutorial bekommst du eine Lösung für das Problem.

In den nächsten Abschnitten werden wir gemeinsam einen Trinkgeldrechner in Java programmieren.

1. Trinkgeldrechner: Die Funktionsweise des Programms

Da das Trinkgeld relativ zu einem Rechnungsbetrag sein soll, z.B. bei einer Restaurant-Quittung, benötigen wir ein Eingabefeld. Dort können wir unseren Rechnungsbetrag eintragen.

Ein zweites Eingabefeld soll für eine Prozentzahl stehen. Die Prozentzahl wird mit unserem Rechnungsbetrag aus der ersten Eingabe verrechnet. Danach erhalten wir ein "angemessenes" Trinkgeld in einem Ausgabefenster.

2. Voraussetzungen - Was benötigst du für das Tutorial?

2.1 IDE (z.B. Eclipse) installieren & einrichten

Um in Java zu programmieren, benötigst du das Java JDK. In einem anderen Tutorial zeige ich dir, wie du Java und das JDK installierst. Außerdem verwenden wir die Eclipse Java IDE.

Kurz gesagt: Eine IDE ist ein Text-Editor, der für das Programmieren konzipiert wurde. Falls du Eclipse noch nicht installiert hast, kannst du es dir hier kostenlos herunterladen.

Nach dem Starten von Eclipse wirst du nach einem Workspace gefragt. Das ist der Ordner, indem deine Projektdateien gespeichert werden. Wähle einen leeren Ordner, über die den Button  "Browse" aus und klicke dann auf "Launch". Siehe Screenshot:

Da die Entwicklung von grafischen Benutzeroberflächen (GUI's) aufwendig ist, installieren wir zusätzlich das Eclipse-Add-on namens "Window Builder". Mit diesem Add-on bekommen wir die Möglichkeit eine Benutzeroberfläche per Drag-and-Drop zu erstellen. Den Java-Code für die Benutzeroberfläche erstellt das Add-on automatisch. Sehr praktisch, da Programmierer bequeme Kreaturen sind!

2.2 Window Builder Add-On installieren

Add-ons kannst du über den "Eclipse Marketplace" installieren. Klicke dafür in der Menüleiste auf "Help" und danach auf "Eclipse Marketplace".

Eclipse Marketplace aufrufen

In die Suchleiste gibst du "Window Builder" ein. Wähle das richtige Add-On aus und klicke auf "Install".

Bestätige das nächste Fenster über "Confirm". Das Addon wird nun heruntergeladen und installiert.

Akzeptiere die Lizenzbedingungen, um den Vorgang abzuschließen:

Nach der Installation bekommst du eine Nachricht, ob du Eclipse neu starten möchtest. Bestätige diese Anforderung mit "Restart Now". (Speichere dieses Tutorial in deinen Browser-Lesezeichen, damit du nach dem Neustart weitermachen kannst.)

3. Neues Projekt in Ecplise erstellen

Erstelle jetzt ein neues Java-Projekt. Klicke dafür auf "File" und dann auf die Menüpunkte "New", "New Java Project".

Ein neues Java-Projekt erstellen

Gib deinem Projekt einen Namen - zum Beispiel "Trinkgeld-Rechner" und bestätige mit "Finish".

Projektname vergeben und Projekt erstellen

Hinweis: Falls du dich wunderst, wo du deinen Code hinschreibst, schließe das "Welcome"-Fenster  über das "X"

4. JFrame hinzufügen

Bist du dem Tutorial soweit gefolgt, dann solltest du links im "Package-Explorer" einen Ordner mit dem von dir gewählten Projektnamen sehen.

Problemlösung: Siehst du das Fenster "Package-Explorer" nicht, so kannst du es über "Window" und danach "Show Views" öffnen. Du solltest ebenso einen Unterordner namens "src" (für source) sehen, mache einen Rechtsklick darauf und wähle "New" und anschließend "Other".

Im Auswahlmenü solltest du einen Ordner namens "WindowBuilder" sowie einen Unterordner namens "Swing Designer" sehen.

Klappe diesen (mit einem Doppeklick) auf und klicke auf JFrame und danach auf "Next".

Ein JFrame ist eine Java-Klasse, mit der du Benutzeroberflächen erstellen kannst. Wähle im Anschluss einen Namen für die Klasse z.B. "TrinkgeldRechner".

Java Swing-Klasse erstellen

5. Benutzeroberfläche (GUI) entwerfen

Eclipse hat bereits eine Datei mit Code angelegt. Da du das WindowBuilder-Add-on installiert hast, kannst du in die "Design-Ansicht" wechseln. Klicke dafür (unter dem Editor) auf "Designs":

Design-Ansicht auswählen

Du siehst jetzt eine Vorschau des Fensters.

Links an der Seite, unter "Palette", siehst du einige Steuerelemente. Diese kannst du, mit einem Klick auf das jeweilige Steuerelement und einem weiteren Klick auf die Vorschau, hinzufügen.

Zuerst fügen wir ein Layout hinzu. Ein Layout definiert, an welcher Position Steuerelemente stehen - zum Beispiel untereinander, nebeneinander, in Form einer Tabelle usw.

Ebenso definiert das Layout, wie sich die Elemente verhalten sollen, wenn sich die Fenstergröße verändert (soll das Textfeld gleich groß bleiben oder dynamisch an die Fenstergröße angepasst werden).

Für den Anfang benutzen wir das "Absolute Layout". Dort können wir jedes Steuerelement nach Belieben verschieben. Klicke dafür auf "Absolute Layout":

Für unser Programm benötigen wir:

1. zwei JTextFields,
2. einen JButton und
3. mehrere JLabel.

Nachdem du diese Steuerelemente hinzugefügt hast, kannst du diese anklicken. Unter dem "Properties-Fenster" kannst du verschiedene Eigenschaften dieser Elemente ändern, wie bspw. Text, Schriftart, Schriftfarbe usw.

Eine wichtige Property-Eigenschaft ist "Variable". Über diesen Namen steuern wir die Steuerelemente später im Code an

1. Ich habe beiden Textfeldern die Variable "geldEingabe" und "prozentEingabe" zugewiesen.
2. Das Ergebnis-Label habe ich "ergebnisLabel" genannt.

Jetzt müssen wir den Code schreiben.

Unsere Trinkgeld-Berechnung soll durchgeführt werden, wenn der Benutzer auf den Button "Berechnen" klickt.

Praktischerweise müssen wir nur einen Doppelklick auf den Button "Berechnen" tätigen, damit wir unseren Code-Schreiben können.

6. Trinkgeldrechner programmieren

Der Java-Code des Trinkgeldrechners soll folgende Schritte ausführen:

1. Lese den Text aus dem Eingabetextfeld für die Geld-Eingabe ein. Speichere diesen Wert als Kommazahl (Datentyp: double)
2. Lese den Text aus dem Eingabetextfeld für die Prozent-Eingabe ein. Speichere diesen Wert als Ganzzahl (Datentyp: int)
3. Berechne Geld-Eingabe * (Prozent-Eingabe / 100) und speichere diesen Wert als Kommazahl (Datentyp: double)
4. Gebe das Ergebnis aus Schritt 3 im Ergebnis-Label aus

Schritt 1: Fangen wir bei Schritt 1 an.

Das Auslesen des Eingabetextfelds mit der Variablenbezeichnung "geldEingabe" erledigen wir mit der Methode getText(). Um diesen Wert als Kommazahl (Double) speichern zu können, müssen wir den Text mit Double.parseDouble() umwandeln:

double betrag = Double.parseDouble(geldEingabe.getText());

Schritt 2: Prozent-Eingabe einlesen

Diesmal lesen wir das Textfeld "prozentEingabe" ein. Der Wert wird als ganze Zahl (int) gespeichert. Damit das funktioniert, müssen wir ihn zunächst in einen Integer-Wert umwandeln. Dafür benötigen wir die Methode Integer.parseInteger():

int prozent = Integer.parseInt(prozentEingabe.getText());

Schritt 3: Berechnung des Trinkgelds

Eine Berechnung der beiden Variablen lässt sich in Java mit den Standardoperatoren (Plus, Minus, usw.) ausführen:

double trinkgeld = betrag * (prozent / 100d);

Schritt 4: Text-Ausgabe des berechneten Trinkgeld

1. Wir müssen den Text unseres Ausgabe-Labels "ergebnisLabel" setzen. Dafür gibt es die Methode setText().
2. Um unser Ergebnis auf zwei Nachkommastellen zu beschränken, können wir String.Format() verwenden.
3. Dabei übergeben wir das Format "%.2f". Erklärung zu %.2f: Bis zum Punkt sollen alle Werte angezeigt werden. Nach dem Punkt werden nur die ersten beiden Ziffern angezeigt. Das "f" steht für Float (Kommazahl). 
4. Mit "rn" können wir eine neue Zeile einleiten.

Im Code sieht das wie folgt aus:

String ausgabe = "Bei einem Rechnungsbetrag von " + betrag + "EUR rnbetraegt das Trinkgeld " + String.format("%.2f", trinkgeld) + " (bei " + prozent + "%)";ergebnisLabel.setText(ausgabe);

7. Trinkgeldrechner-Projekt testen & debuggen

Nun können wir unser Projekt testen. Klicke dafür auf die grüne Schaltfläche mit dem Start-Icon:

Beim Testen musst du darauf achten, dass du für Kommazahlen einen Punkt verwendest:

• Richtig: 25.5 €
• Falsch: 25,5 €

Außerdem versteht das Programm bei Prozentwerten ausschließlich ganze Zahlen. 

8. Der komplette Code des Trinkgeldrechners

Zum Schluss möchte ich dir noch meinen Projektcode zur Verfügung stellen

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.Font;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.SwingConstants;

public class TrinkgeldRechner extends JFrame {

	private JPanel contentPane;
	private JTextField geldEingabe;
	private JTextField prozentEingabe;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					TrinkgeldRechner frame = new TrinkgeldRechner();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public TrinkgeldRechner() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 548, 224);
		contentPane = new JPanel();
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		contentPane.setLayout(null);
		
		geldEingabe = new JTextField();
		geldEingabe.setFont(new Font("Tahoma", Font.PLAIN, 14));
		geldEingabe.setBounds(82, 42, 440, 20);
		contentPane.add(geldEingabe);
		geldEingabe.setColumns(10);
		
		prozentEingabe = new JTextField();
		prozentEingabe.setFont(new Font("Tahoma", Font.PLAIN, 14));
		prozentEingabe.setBounds(82, 73, 440, 20);
		contentPane.add(prozentEingabe);
		
		prozentEingabe.setColumns(10);
		JLabel ergebnisLabel = new JLabel("Ergebnis:");
		ergebnisLabel.setVerticalAlignment(SwingConstants.TOP);
		ergebnisLabel.setFont(new Font("Tahoma", Font.PLAIN, 13));
		ergebnisLabel.setBounds(10, 152, 512, 33);
		contentPane.add(ergebnisLabel);
			 		 		
		JLabel lblNewLabel = new JLabel("Trinkgeldrechner");
		lblNewLabel.setFont(new Font("Tahoma", Font.BOLD, 27));
		lblNewLabel.setBounds(10, 0, 250, 33);
		contentPane.add(lblNewLabel);
		
		JLabel lblGeldbetrag = new JLabel("Geldbetrag");
		lblGeldbetrag.setFont(new Font("Tahoma", Font.PLAIN, 14));
		lblGeldbetrag.setBounds(10, 45, 73, 17);
		contentPane.add(lblGeldbetrag);
		
		JLabel lblNewLabel_1_1 = new JLabel("Prozent ");
		lblNewLabel_1_1.setFont(new Font("Tahoma", Font.PLAIN, 14));
		lblNewLabel_1_1.setBounds(10, 76, 62, 14);
		contentPane.add(lblNewLabel_1_1);
		
		JButton btnNewButton = new JButton("Berechnen");
		btnNewButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				double betrag = Double.parseDouble(geldEingabe.getText());
				int prozent = Integer.parseInt(prozentEingabe.getText());
				double trinkgeld = betrag * (prozent / 100d);
				String ausgabe = "Bei einem Rechnungsbetrag von " + betrag + "€ beträgt das Trinkgeld " + String.format("%.2f", trinkgeld) + 
						" (bei " + prozent + "%)";
				ergebnisLabel.setText(ausgabe);
			}
		});
		
		btnNewButton.setFont(new Font("Tahoma", Font.BOLD, 16));
		btnNewButton.setBounds(10, 104, 512, 45);
		contentPane.add(btnNewButton);
		
 
	}
}

Fazit zum Trinkgeldrechner-Tutorial in Java

Mit diesem Rechner musst du jetzt endlich keine Trinkgelder mehr ausrechnen.

Hoffentlich hast du in diesem Tutorial gelernt, dass dir ein gutes Set-up, bestehend aus einer IDE (Eclipse) sowie Add-ons (bspw. WindowHelper) viel Zeit beim Programmieren einsparen.

Wenn du magst, kannst du das Programm natürlich um weitere Features ergänzen.