14.1 Zählerschleife

Aufgabe

Aufgabe 14-1: Szenario – „Geh neunmal vorwärts!“

Ziel dieses Szenarios ist es, einen roten Roboter zu erzeugen, der auf Feld (1; 1) startet und mit einer Geschwindigkeit von 4 zum Zielfeld (3; 4) fährt.

img/Abb_14_1_Spielbrett_s8.jpg
Abb. 14-1: Spielbrett s8
Aufgabe
  1. Erstellen Sie den Quellcode der Klasse Szenario. Lösung
    Lösung
    JAVA
    package welt;

    public class Szenario {

        private Roboter robi;
        
        public void erstelleRobi(Spielbrett pSpielbrett){
            robi = new Roboter();
            robi.setSpielbrett(pSpielbrett);
            robi.starteAufFeld(1,1);
            robi.setFarbe("rot");
            robi.setGeschwindigkeit(4);
        }
            
        public void steuereRobi() {
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            
            robi.drehRechts();

            robi.gehVorwaerts();
            robi.gehVorwaerts();
            
            robi.drehRechts();

            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            robi.gehVorwaerts();
            
            robi.drehLinks();
            
            robi.gehVorwaerts();
        }
        
    }
    Abb. 14-2: Klasse Szenario (Quellcode)
  2. Informieren Sie sich mit Hilfe des folgenden Beispiels über die Zählerschleife. Ersetzen Sie anschließend alle im Quellcode vorhandenen Wiederholungen durch eine Zählerschleife. Lösung
    Lösung
    JAVA
    public void steuereRobi() {
        for(int i=1; i<=9; i=i+1) {
            robi.gehVorwaerts();
        }
        
        robi.drehRechts();

        robi.gehVorwaerts();
        robi.gehVorwaerts();
        
        robi.drehRechts();

        for(int i=1; i<=7; i=i+1) {
            robi.gehVorwaerts();
        }
        
        robi.drehLinks();
        
        robi.gehVorwaerts();
    }
    Abb. 14-3: Methode steuereRobi() (Quellcode)
  3. Erstellen Sie in der Klasse RoboterErweitert die Methode gehVorwaerts(pFelder: int) und nutzen Sie diese im aktuellen Szenario. Lösung
    Lösung
    JAVA
    package welt;

    public class RoboterErweitert extends Roboter {

        //...

        public void gehVorwaerts(int pFelder) {
            for(int i=1; i<=pFelder; i++) {
                this.gehVorwaerts();
            }
        }

    }
    Abb. 14-4: Klasse RoboterErweitert (Quellcode)
    JAVA
    package welt;

    public class Szenario {

        private RoboterErweitert robi;
        
        public void erstelleRobi(Spielbrett pSpielbrett){
            robi = new RoboterErweitert();
            robi.setSpielbrett(pSpielbrett);
            robi.starteAufFeld(1,1);
            robi.setFarbe("rot");
            robi.setGeschwindigkeit(4);
        }
            
        public void steuereRobi() {
            robi.gehVorwaerts(9);
            robi.drehRechts();
            robi.gehVorwaerts(2);
            robi.drehRechts();
            robi.gehVorwaerts(7);
            robi.drehLinks();
            robi.gehVorwaerts();
        }
        
    }
    Abb. 14-5: Klasse Szenario (Quellcode)
Beispiel: Zählerschleife
  • Struktogramm

    img/Abb_14_6_Struktogramm_Zaehlerschleife.svg
    Abb. 14-6: Zählerschleife (Struktogramm)
  • Java-Code

    img/Abb_14_7_Quellcode_Zaehlerschleife.svg
    Abb. 14-7: Zählerschleife (Quellcode)
  • Ablauf

    img/Abb_14_8_Ablauf_Zaehlerschleife.svg
    Abb. 14-8: Zählerschleife (Ablauf)
  • Erläuterungen

    1. Zählervariable deklarieren und initialisieren

      • Die Variable wird im Schleifenkopf deklariert und ist damit nur innerhalb der Schleife bekannt (lokale Variable).
      • Die Deklaration und Initialisierung einer Variable können auch in einer einzigen Anweisung zusammengefasst werden:
        img/Abb_14_9_Deklaration_Initialisierung.svg
        Abb. 14-9: Deklaration und Initialisierung einer Variable
      • Die Deklaration und Initialisierung wird genau einmal vor dem ersten Durchlauf der Schleife ausgeführt.
    2. Bedingung (boolescher Ausdruck) prüfen

      • Vor jeder Wiederholung der Schleife wird geprüft, ob der boolesche Ausdruck wahr (true) oder falsch (false) ist.
      • Ergibt die Prüfung true, werden die Anweisungen innerhalb des Schleifenkörpers einmal ausgeführt.
      • Ergibt die Prüfung false, wird die Schleife verlassen.
    3. Wert der Zählervariable um 1 erhöhen

      • Nach jeder Wiederholung der Schleife wird der Wert der Zählervariable um 1 erhöht:
        img/Abb_14_10_Zaehlervariable_um_1_erhoehen.svg
        Abb. 14-10: Variablenwert um 1 erhöhen
      • Anschließend wird die Bedingung erneut geprüft.

Mit Hilfe einer Zählerschleife kann festgelegt werden, wie oft bestimmte Anweisungen wiederholt werden.

Wird die Anzahl der Wiederholungen im Quellcode nicht durch einen festen Wert, sondern mit Hilfe einer Variable festgelegt, ist es möglich die tatsächliche Anzahl der Wiederholungen erst während der Laufzeit zu bestimmen.

Auch wenn die Anzahl der Wiederholungen bereits zur Entwicklungszeit feststeht, bietet die Zählerschleife den Vorteil, dass sich wiederholende Anweisungen nur einmal codiert werden müssen. Zum einen erhöht dies die Verständlichkeit des Quellcodes, zum anderen muss eine Änderung an den sich wiederholenden Anweisungen nur einmal vorgenommen werden.

Merke: Zählerschleife
Aufgabe

Aufgabe 14-2: Würfeln

Entwickeln Sie auf Grundlage des vorgegebenen Klassendiagramms (vgl. Abb 14-12) ein Programm, das den Benutzer zunächst fragt, wie oft mit einem Würfel gewürfelt werden soll. Anschließend soll es die Würfe simulieren und die gewürfelten Augenzahlen auf der Konsole ausgeben.

Konsole
Würfeln
-------
wie oft? 4

Würfe:
1
3
1
5
Abb. 14-11: Konsole mit Würfelergebnissen (Beispieldaten)
img/Abb_14_12_UML_Wuerfeln.svg
Abb. 14-12: Würfeln (UML)
Aufgabe

Erstellen Sie den Quellcode der Klasse Wuerfelsimulation. Die übrigen Klassen werden Ihnen zur Verfügung gestellt.

Die Methode erstelleErgebnisliste(): String der Klasse Wuerfelsimulation soll einen String zurückgeben, der alle gewürfelten Werte enthält. Die einzelnen Werte sollen dabei jeweils durch einen Zeilenumbruch ("\n") voneinander getrennt werden.

Lösung
Lösung
JAVA
public class Wuerfelsimulation {

    private int anzahlWuerfe;
    private Wuerfel wuerfel = new Wuerfel();
    
    public int getAnzahlWuerfe() {
        return anzahlWuerfe;
    }
    public void setAnzahlWuerfe(int pAnzahlWuerfe) {
        anzahlWuerfe = pAnzahlWuerfe;
    }
    
    public String erstelleErgebnisliste() {
        String ergebnisliste = "";
        
        for(int i=1; i<=anzahlWuerfe; i++) {
            ergebnisliste = ergebnisliste + wuerfel.wuerfeln() + "\n";
        }
        
        return ergebnisliste;
    }
    
}
Abb. 14-13: Klasse Szenario (Quellcode)
Aufgabe

Aufgabe 14-3: Das kleine Einmaleins

Erstellen Sie auf Grundlage des vorgegebenen Klassendiagramms (vgl. Abb 14-15) die Fachklasse Einmaleins, mit deren Hilfe je nach Bedarf ein beliebiges kleines Einmaleins erstellt werden kann.

Testen Sie abschließend die Klasse Einmaleins.

Konsole
1*2=2
2*2=4
3*2=6
4*2=8
5*2=10
6*2=12
7*2=14
8*2=16
9*2=18
10*2=20
Abb. 14-14: Das 2er-Einmaleins (Beispiel)
img/Abb_14_15_UML_Einmaleins.svg
Abb. 14-15: Einmaleins (UML)
Hinweise zum Lösungsweg

Die Methode erstelleEinmaleins() der Klasse Einmaleins soll einen String zurückgeben, der das gesamte Einmaleins enthält. Diesen String setzen wir nun Schritt für Schritt zusammen.

  1. Jedes Einmaleins setzt sich aus zehn Zeilen zusammen. Aus welchen Bestandteilen ist jede dieser Zeilen allgemein aufgebaut? Welche dieser Bestandteile ändern sich von Zeile zu Zeile bzw. je nach gewähltem Einmaleins? Lösung
    Lösung

    Jede Zeile setzt sich aus dem 1. Faktor, dem String "*", dem 2. Faktor, dem String "=" und dem Produkt zusammen.

    Der 1. Faktor und das Produkt sind variabel und ändern sich von Zeile zu Zeile.

  2. Verwenden Sie für die veränderlichen Bestandteile einer Zeile, jeweils eine geeignete Variable und verknüpfen Sie diese mit den unveränderlichen Textbausteinen ("*" bzw. "=") so zu einem String, dass sich die gewünschte Zeile ergibt. Den Zeilenumbruch erreichen Sie, indem Sie am Ende einer jeden Zeile den String "\n" anhängen. Weisen Sie die fertige Zeile einer lokalen Variable vom Typ String zu. Lösung
    Lösung
    JAVA
    int produkt;
    String zeile;

    produkt = faktor1 * this.zahl;
    zeile = faktor1 + "*" + this.zahl + "=" + produkt + "\n";
    Abb. 14-16: Aufbau einer Zeile des Einmaleins (Quellcode)
  3. Sorgen Sie dafür, dass Schritt II) für jede der zehn Zeilen wiederholt wird. Auf dieses Weise wird das Einmaleins Schritt für Schritt um die gerade neu zusammengesetzte Zeile erweitert bis alle zehn Zeilen vorhanden sind. Achten Sie darauf, dass die gerade neu zusammengesetzte Zeile die bereits vorhandenen Zeilen des Einmaleins nicht ersetzt! Die neue Zeile soll an die bisherigen Zeilen angehängt werden! Lösung
    Lösung
    JAVA
    int produkt;
    String zeile;
    String einmaleins = "";

    for(int faktor1=1; faktor1<=10; faktor1++) {
        produkt = faktor1 * this.zahl;
        zeile = faktor1 + "*" + this.zahl + "=" + produkt + "\n";
        einmaleins = einmaleins + zeile;
    }
    Abb. 14-17: Jede Zeile wird zusammengesetzt und an das Einmaleins angefügt (Quellcode)
  4. Am Ende der Methode geben Sie die lokale Variable, die das fertige Einmaleins enthält, mit Hilfe der return-Anweisung an das aufrufende Objekt zurück. Lösung
    Lösung
    JAVA
    public String erstelleEinmaleins() {
        int produkt;
        String zeile;
        String einmaleins = "";
        
        for(int faktor1=1; faktor1<=10; faktor1++) {
            produkt = faktor1 * this.zahl;
            zeile = faktor1 + "*" + this.zahl + "=" + produkt + "\n";
            einmaleins = einmaleins + zeile;
        }

        return einmaleins;
    }
    Abb. 14-18: Die Methode erstelleEinmaleins(): String (Quellcode)
  5. Testen Sie nun Ihre Klasse Einmaleins. Erzeugen Sie dazu in der main()-Methode der Klasse Test ein Objekt der Klasse Einmaleins (z. B. 2er-Einmaleins). Rufen Sie dann die Methode erstelleEinmaleins() des Objekts auf und geben Sie den Rückgabewert auf der Konsole aus. Nach dem Programmstart sollte auf der Konsole nun das komplette Einmaleins erscheinen. Lösung
    Lösung
    JAVA
    public class Test {

        public static void main(String[] args) {
            Einmaleins einmaleins = new Einmaleins(2);
            System.out.println(einmaleins.erstelleEinmaleins());
        }

    }
    Abb. 14-19: Die Methode erstelleEinmaleins(): String (Quellcode)
    JAVA
    public class Einmaleins {

        private int zahl;
        
        public Einmaleins(int pZahl) {
            this.zahl = pZahl;
        }
        
        public int getZahl() {
            return zahl;
        }

        public String erstelleEinmaleins() {
            int produkt;
            String zeile;
            String einmaleins = "";
            
            for(int faktor1=1; faktor1<=10; faktor1++) {
                produkt = faktor1 * this.zahl;
                zeile = faktor1 + "*" + this.zahl + "=" + produkt + "\n";
                einmaleins = einmaleins + zeile;
            }

            return einmaleins;
        }
    }
    Abb. 14-20: Die Klasse Einmaleins (Quellcode)
Aufgabe

Aufgabe 14-4: Kapitalanlage mit fester Laufzeit

Erstellen Sie eine Java-Anwendung, die nach Eingabe von Anfangskapital, Zinssatz und festgelegter Laufzeit die Kapitalentwicklung veranschaulicht. Die Erfassung und Ausgabe der Daten soll mit Hilfe der Konsole erfolgen.

Konsole
Kapitalanlage mit fester Laufzeit
---------------------------------

Bitte geben Sie die folgenden Informationen
zu der gewünschten Kapitalanlage ein:

Anfangskapital (in EUR): 1000
Zinssatz p. a. (in %): 10
Laufzeit (in Jahren): 3

Kapitalentwicklung
==================
Jahr  Zinsen       Endkapital
-------------------------------
1     100,00 EUR   1.100,00 EUR
2     110,00 EUR   1.210,00 EUR
3     121,00 EUR   1.331,00 EUR
Abb. 14-21: Konsole mit Kapitalentwicklung (Beispieldaten)
Hinweise
  • Die Zeichenfolge "\t" fügt an der entsprechenden Stelle einen Tabulator ein.
  • Verzichten Sie zunächst auf die Formatierung der Währungsbeträge. Haben Sie Ihr Programm erfolgreich getestet, können Sie diese mit Hilfe des folgenden Abschnitts „Formatierung von Währungsbeträgen“ nachholen.

Formatierung von Währungsbeträgen

Eine Zahl lässt sich mit Hilfe der Klasse DecimalFormat formatieren. Dazu erzeugt man ein Objekt der Klasse DecimalFormat und teilt ihr dabei mit, nach welchem Muster dieses Objekt Zahlen formatieren soll.

Das folgende Beispiel zeigt die Methode formatWaehrung(pZahl: double): String, die einen übergebenen double-Wert als Währungsbetrag formatiert und in Form eines Strings zurückgibt.

JAVA
public static String formatWaehrung(double pZahl) {
    DecimalFormat decFormat = new DecimalFormat("#,##0.00");
        
    return decFormat.format(pZahl) + " EUR";
}
Abb. 14-22: Die Methode formatWaehrung(pZahl: double): String (Quellcode)

Um diese Methode auch in zukünftigen Projekten verwenden zu können, wurde sie mit Hilfe des Schlüsselworts static als Klassenmethode deklariert. Auf diese Weise kann sie zum Beispiel in unsere in Aufgabe 13-1 erstellte Utility-Klasse Werkzeug integriert werden.

Falls Sie das Kapitel 13.2 Klassenmethoden nicht bearbeitet haben, entfernen Sie aus dem Methodenkopf das Schlüsselwort static. Auf diese Weise erhalten Sie eine gewöhnliche Objektmethode.

Lösung
Lösung
JAVA
package app;

import java.text.DecimalFormat;
import myBib.Werkzeug;
public class Kapitalanlage {

    private double anfangskapital;
    private double zinssatz;
    private int laufzeit;

    public Kapitalanlage(){
    }

    public Kapitalanlage(double pAnfangskapital, double pZinssatz, int pLaufzeit){
        this.anfangskapital = pAnfangskapital;
        this.zinssatz = pZinssatz;
        this.laufzeit = pLaufzeit;
    }

    public void setAnfangskapital (double pAnfangskapital){
        this.anfangskapital = pAnfangskapital;
    }
    
    public double getAnfangskapital(){
        return this.anfangskapital;
    }

    public void setZinssatz (double pZinssatz){
        this.zinssatz = pZinssatz;
    }
    
    public double getZinssatz (){
        return this.zinssatz;
    }

    public void setLaufzeit (int pLaufzeit){
        this.laufzeit = pLaufzeit;
    }
    
    public int getLaufzeit (){
        return this.laufzeit;
    }
    
    public String erstelleKapitalentwicklung() {
        double zinsen;
        double kapital;
        String kapitalentwicklung = "";
        
        kapitalentwicklung = "Jahr\tZinsen\t\tEndkapital\n"
                           + "------------------------------------ \n";
        
        kapital = anfangskapital;
        for(int jahr=1; jahr <= laufzeit; jahr++) {
            zinsen = kapital * (zinssatz / 100);
            zinsen = Math.round(zinsen * 100) / 100.0;
            zinsen = Werkzeug.runden(zinsen, 2);
            kapital = kapital + zinsen;
            kapitalentwicklung = kapitalentwicklung + jahr + "\t"
                                   + zinsen + "\t"
                                   + kapital + "\n";
                                   + this.formatWaehrung(zinsen) + "\t"
                                   + this.formatWaehrung(kapital) + "\n";
                                   + Werkzeug.formatWaehrung(zinsen) + "\t"
                                   + Werkzeug.formatWaehrung(kapital) + "\n";
        }
        
        return kapitalentwicklung;
    }

    public String formatWaehrung(double pZahl) {
        DecimalFormat decFormat = new DecimalFormat("#,##0.00");
            
        return decFormat.format(pZahl) + " EUR";
    }
}

Zinsen auf zwei Nachkommastellen runden: 

Geldbeträge formatiert darstellen: 
Abb. 14-23: Die Klasse Kapitalanlage (Quellcode)
JAVA
package ui;

import app.Kapitalanlage;

public class Benutzerkonsole {

    private Kapitalanlage kapitalanlage;
    
    public Benutzerkonsole(){
        this.erfasseDaten();
        this.zeigeDaten();
    }
    
    public void erfasseDaten(){
        ConsoleReader consoleReader = new ConsoleReader();
        double anfangskapital;
        double zinssatz;
        int laufzeit;
        
        System.out.println("Bitte geben Sie die folgenden Informationen\nzu der gewünschten Kapitalanlage ein:" + "\n");
        System.out.print("Anfangskapital (in EUR): ");
        anfangskapital = consoleReader.nextDouble();
        System.out.print("Zinssatz p. a. (in %): ");
        zinssatz = consoleReader.nextDouble();
        System.out.print("Laufzeit (in Jahren): ");
        laufzeit = consoleReader.nextInt();
        System.out.println("");
        
        kapitalanlage = new Kapitalanlage (anfangskapital, zinssatz, laufzeit);
    }
    
    public void zeigeDaten(){
        System.out.println("Kapitalentwicklung");
        System.out.println("==================");
        System.out.println(kapitalanlage.erstelleKapitalentwicklung());
    }
    
}
Abb. 14-24: Die Klasse Benutzerkonsole (Quellcode)
JAVA
package myBib;

import java.text.DecimalFormat;

public class Werkzeug {
    
    public static String formatWaehrung(double pZahl) {
        DecimalFormat decFormat = new DecimalFormat("#,##0.00");
            
        return decFormat.format(pZahl) + " EUR";
    }

    public static double runden(double pZahl, int pNachkommastellen) {
        return Math.round(pZahl * Math.pow(10, pNachkommastellen)) / Math.pow(10, pNachkommastellen);
    }
    
}
Abb. 14-25: Die Klasse Werkzeug (Quellcode)
Aufgabe

Aufgabe 14-5: Abschreibung von Sachanlagen (lineare Methode)

Erstellen Sie eine Java-Anwendung, die nach Eingabe der Anlagennummer, der Anschaffungskosten und der Nutzungsdauer einer Sachanlage deren Abschreibungsplan erstellt (lineare Methode).

Konsole
Abschreibung von Sachanlagen
----------------------------

Bitte geben Sie folgende Daten der
abzuschreibenden Sachanlage ein:

Anlagennummer: A75-XRF3
Anschaffungskosten (in EUR): 30000
Nutzungsdauer (in Jahren): 6

Abschreibungsplan (lineare Methode)
===================================
Jahr Abschreibungsbetrag Restwert
--------------------------------------
1    5.000,00 EUR        25.000,00 EUR
2    5.000,00 EUR        20.000,00 EUR
3    5.000,00 EUR        15.000,00 EUR
4    5.000,00 EUR        10.000,00 EUR
5    5.000,00 EUR        5.000,00 EUR
6    5.000,00 EUR        0,00 EUR
Abb. 14-26: Konsole lineare Abschreibung einer Sachanlage (Beispieldaten)
Lösung
Lösung
JAVA
package app;

import java.text.DecimalFormat;

import myBib.Werkzeug;

public class Sachanlage {

    private String anlagennummer;
    private double anschaffungskosten;
    private int nutzungsdauer;
    
    public Sachanlage() {
    }

    public Sachanlage(String pAnlagennummer, double pAnschaffungskosten, int pNutzungdauer) {
        this.anlagennummer = pAnlagennummer;
        this.anschaffungskosten = pAnschaffungskosten;
        this.nutzungsdauer = pNutzungdauer;
    }

    public String getAnlagennummer() {
        return this.anlagennummer;
    }

    public void setAnlagennummer(String pAnlagennummer) {
        this.anlagennummer = pAnlagennummer;
    }

    public double getAnschaffungskosten() {
        return this.anschaffungskosten;
    }

    public void setAnschaffungskosten(double pAnschaffungskosten) {
        this.anschaffungskosten = pAnschaffungskosten;
    }

    public int getNutzungsdauer() {
        return this.nutzungsdauer;
    }

    public void setNutzungsdauer(int pNutzungdauer) {
        this.nutzungsdauer = pNutzungdauer;
    }

    public String erstelleAbschreibungsplanLinear() {
        String abschreibungsplan;
        double restwert;
        double abschreibungsbetrag;

        abschreibungsbetrag = anschaffungskosten / nutzungsdauer;

        abschreibungsplan = "Jahr\tAbschreibungsbetrag\tRestwert\n"
                          + "---------------------------------------------\n";

        restwert = anschaffungskosten;

        for (int i =1;i<=nutzungsdauer;i++){
            restwert = restwert - abschreibungsbetrag;
            abschreibungsplan = abschreibungsplan + i + "\t"
                                 + abschreibungsbetrag + "\t\t\t"
                                 + restwert + "\n";
                                 + this.formatWaehrung(abschreibungsbetrag) + "\t\t"
                                 + this.formatWaehrung(restwert) + "\n";
                                 + Werkzeug.formatWaehrung(abschreibungsbetrag) + "\t\t"
                                 + Werkzeug.formatWaehrung(restwert) + "\n";
        }

        return abschreibungsplan;
    }

    public String formatWaehrung(double pZahl) {
        DecimalFormat decFormat = new DecimalFormat("#,##0.00");
            
        return decFormat.format(pZahl) + " EUR";
    }
}
Geldbeträge formatiert darstellen: 
Abb. 14-27: Die Klasse Sachanlage (Quellcode)
JAVA
package ui;

import app.Sachanlage;

public class Benutzerkonsole {

    private Sachanlage sachanlage;
    
    public Benutzerkonsole(){
        this.erfasseDaten();
        this.zeigeDaten();
    }
    
    public void erfasseDaten(){
        ConsoleReader consoleReader = new ConsoleReader();
        String anlagennummer;
        double anschaffungskosten;
        int nutzungsdauer;
        
        System.out.println("Abschreibung von Sachanlagen");
        System.out.println("----------------------------\n");
        System.out.println("Bitte geben Sie folgende Daten der\nabzuschreibenden Sachanlage ein:\n");
        System.out.print("Anlagennummer: ");
        anlagennummer = consoleReader.nextString();
        System.out.print("Anschaffungskosten (in EUR): ");
        anschaffungskosten = consoleReader.nextDouble();
        System.out.print("Nutzungsdauer (in Jahren): ");
        nutzungsdauer = consoleReader.nextInt();
        
        sachanlage = new Sachanlage(anlagennummer, anschaffungskosten, nutzungsdauer);
    }
    
    public void zeigeDaten(){
        System.out.println("\nAbschreibungsplan (lineare Methode)");
        System.out.println("===================================");
        System.out.println(sachanlage.erstelleAbschreibungsplanLinear());
    }
    
}
Abb. 14-28: Die Klasse Benutzerkonsole (Quellcode)
JAVA
package myBib;

import java.text.DecimalFormat;

public class Werkzeug {
    
    public static String formatWaehrung(double pZahl) {
        DecimalFormat decFormat = new DecimalFormat("#,##0.00");
            
        return decFormat.format(pZahl) + " EUR";
    }

    public static double runden(double pZahl, int pNachkommastellen) {
        return Math.round(pZahl * Math.pow(10, pNachkommastellen)) / Math.pow(10, pNachkommastellen);
    }
    
}
Abb. 14-29: Die Klasse Werkzeug (Quellcode)