14.2 Abweisende Schleife
Aufgabe 14-6: Szenario – „Geh vorwärts, solange der Weg frei ist!“
Ziel dieses Szenarios ist es, einen blauen Roboter zu erzeugen, der auf Feld (1; 2) startet und mit einer Geschwindigkeit von 4 zum Zielfeld fährt.
Allerdings liegt nur eine ungefähre Skizze des Spielbrettes vor, aus der die genaue Länge der einzelnen Wegabschnitte nicht hervorgeht. Es ist daher nicht möglich, dem Roboter vorzugeben, wie viele Felder er auf den verschiedenen Wegabschnitten jeweils vorwärts gehen soll.
Abb. 14-30: Spielbrett s8
Aufgabe
Informieren Sie sich mit Hilfe des folgenden Beispiels über die abweisende Schleife und erstellen Sie dann 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, 2);
robi .setFarbe("blau" );
robi .setGeschwindigkeit(4);
}
public void steuereRobi() {
while (robi .istWegFrei()) {
robi .gehVorwaerts();
}
robi .drehRechts();
while (robi .istWegFrei()) {
robi .gehVorwaerts();
}
robi .drehLinks();
while (robi .istWegFrei()) {
robi .gehVorwaerts();
}
robi .drehLinks();
while (robi .istWegFrei()) {
robi .gehVorwaerts();
}
}
}
Abb. 14-31: Klasse Szenario (Quellcode)
Erstellen Sie in der Klasse RoboterErweitert
die Methode gehVorwaertsSolangeWegFrei()
und nutzen Sie diese im aktuellen Szenario
.
Lösung
Lösung
JAVA
package welt;
public class RoboterErweitert extends Roboter{
//...
public void gehVorwaertsSolangeWegFrei() {
while (this .istWegFrei()) {
super .gehVorwaerts();
}
}
}
Abb. 14-32: 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, 2);
robi .setFarbe("blau" );
robi .setGeschwindigkeit(4);
}
public void steuereRobi() {
robi .gehVorwaertsSolangeWegFrei();
robi .drehRechts();
robi .gehVorwaertsSolangeWegFrei();
robi .drehLinks();
robi .gehVorwaertsSolangeWegFrei();
robi .drehLinks();
robi .gehVorwaertsSolangeWegFrei();
}
}
Abb. 14-33: Klasse Szenario (Quellcode)
Beispiel: Abweisende Schleife
Struktogramm
img/Abb_14_34_Struktogramm_Abweisende_Schleife.svg
Abb. 14-34: Abweisende Schleife (Struktogramm)
Java-Code
img/Abb_14_35_Quellcode_Abweisende_Schleife.svg
Abb. 14-35: Abweisende Schleife (Quellcode)
Ablauf
img/Abb_14_36_Ablauf_Abweisende_Schleife.svg
Abb. 14-36: Abweisende Schleife (Ablauf)
Aufgabe 14-7: Kapitalanlage mit einem bestimmten Zielkapital
Erstellen Sie eine Java-Anwendung, die nach Eingabe des Anfangskapitals, des Zinssatzes und des gewünschten Zielkapitals die Kapitalentwicklung veranschaulicht. Die Erfassung und Ausgabe der Daten soll mit Hilfe der Konsole erfolgen.
Konsole
Kapitalanlage mit einem bestimmten Zielkapital
----------------------------------------------
Bitte geben Sie die folgenden Informationen
zu der gewünschten Kapitalanlage ein:
Anfangskapital (in EUR): 1000
Zinssatz p. a. (in %): 10
Zielkapital (in EUR): 1400
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
4 133,10 EUR 1.464,10 EUR
Abb. 14-37: Konsole mit Kapitalentwicklung (Beispieldaten)
Lösung
Lösung
JAVA
package app;
import java.text.DecimalFormat;
import myBib.Werkzeug;
public class Kapitalanlage {
private double anfangskapital ;
private double zinssatz ;
private double zielkapital ;
public Kapitalanlage(){
}
public Kapitalanlage(double pAnfangskapital , double pZinssatz , double pZielkapital ){
this .anfangskapital = pAnfangskapital ;
this .zinssatz = pZinssatz ;
this .zielkapital = pZielkapital ;
}
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 setZielkapital(double pZielkapital ) {
this .zielkapital = pZielkapital ;
}
public double getZielkapital() {
return this .zielkapital ;
}
public String erstelleKapitalentwicklung() {
double zinsen ;
double kapital = anfangskapital ;
int jahr = 1;
String kapitalentwicklung = "" ;
kapitalentwicklung = "Kapitalentwicklung\n"
+ "================== \n"
+ "Jahr\tZinsen\t\tEndkapital\n"
+ "------------------------------------ \n" ;
while (kapital < zielkapital ) {
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" ;
jahr ++;
}
return kapitalentwicklung ;
}
public String formatWaehrung(double pZahl ) {
DecimalFormat decFormat = new DecimalFormat("#,##0.00" );
return decFormat .format(pZahl ) + " EUR" ;
}
}
Zinsen auf zwei Nachkommastellen runden:
nein
Math.round(double a)
Werkzeug.runden(double pZahl, int pNachkommastellen)
Geldbeträge formatiert darstellen:
nein
this.formatWaehrung(double pZahl)
Werkzeug.formatWaehrung(double pZahl)
Abb. 14-38: 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 ;
double zielkapital ;
System.out.println("Kapitalanlage mit einem bestimmten Zielkapital" );
System.out.println("----------------------------------------------\n" );
System.out.println("Bitte geben Sie die folgenden Informationen\nzu der gewünschten Kapitalanlage ein.\n" );
System.out.print("Anfangskapital: " );
anfangskapital = consoleReader .nextDouble();
System.out.print("Zinssatz: " );
zinssatz = consoleReader .nextDouble();
System.out.print("Zielkapital: " );
zielkapital = consoleReader .nextDouble();
System.out.println("" );
kapitalanlage = new Kapitalanlage(anfangskapital , zinssatz , zielkapital );
}
public void zeigeDaten(){
System.out.println(kapitalanlage .erstelleKapitalentwicklung());
}
}
Abb. 14-39: 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-40: Die Klasse Werkzeug
(Quellcode)
Aufgabe 14-8: Kapitalanlage mit jährlicher Ausschüttung zum Jahresbeginn
Erstellen Sie eine Java-Anwendung, die nach Eingabe des jeweiligen Anfangskapitals, des Zinssatzes und der jeweils zu Jahresbeginn gewünschten Auszahlung die Kapitalentwicklung veranschaulicht. Die Erfassung und Ausgabe der Daten soll mit Hilfe der Konsole erfolgen.
Konsole
Kapitalanlage mit jährlicher Ausschüttung zum Jahresbeginn
----------------------------------------------------------
Bitte geben Sie die folgenden Informationen
zu der gewünschten Kapitalanlage ein:
Anfangskapital (in EUR): 50000
Zinssatz p. a. (in %): 5,4
Auszahlung p. a. (in EUR): 9200
Kapitalentwicklung
==================
Jahr Auszahlung Zinsen  Endkapital
-------------------------------------------------
1 9.200,00 EUR 2.203,20 EUR 43.003,20 EUR
2 9.200,00 EUR 1.825,37 EUR  35.628,57 EUR
3 9.200,00 EUR 1.427,14 EUR 27.855,72 EUR
4 9.200,00 EUR 1.007,41 EUR 19.663,12 EUR
5 9.200,00 EUR 565,01 EUR 11.028,13 EUR
6 9.200,00 EUR 98,72 EUR 1.926,85 EUR
7 1.926,85 EUR 0,00 EUR 0,00 EUR
Abb. 14-41: Konsole mit Kapitalentwicklung (Beispieldaten)
Lösung
Lösung
JAVA
package app;
import java.text.DecimalFormat;
import myBib.Werkzeug;
public class Kapitalanlage {
private double anfangskapital ;
private double zinssatz ;
private double auszahlung ;
public double getAnfangskapital() {
return anfangskapital ;
}
public void setAnfangskapital(double anfangskapital ) {
this .anfangskapital = anfangskapital ;
}
public double getAuszahlung() {
return auszahlung ;
}
public void setAuszahlung(double auszahlung ) {
this .auszahlung = auszahlung ;
}
public double getZinssatz() {
return zinssatz ;
}
public void setZinssatz(double zinssatz ) {
this .zinssatz = zinssatz ;
}
public String erstelleKapitalentwicklung() {
double zinsen ;
double kapital ;
double zahlung = auszahlung ;
int jahr = 1;
String kapitalentwicklung = "" ;
kapitalentwicklung = "Kapitalentwicklung\n"
+ "================== \n"
+ "Jahr\tAuszahlung\tZinsen\t\tEndkapital\n"
+ "-------------------------------------------------- \n" ;
if (anfangskapital *(zinssatz /100) < auszahlung ) {
kapital = anfangskapital ;
while (kapital > 0) {
if (kapital < auszahlung ) {
zahlung = kapital ;
}
kapital = kapital - zahlung ;
zinsen = kapital * (zinssatz / 100);
zinsen = Math.round(zinsen * 100) / 100.0;
zinsen = Werkzeug.runden(zinsen , 2);
kapital = kapital + zinsen ;
kapitalentwicklung = kapitalentwicklung + jahr + "\t"
+ zahlung + "\t"
+ zinsen + "\t"
+ kapital + "\n" ;
+ this .formatWaehrung(zahlung ) + "\t"
+ this .formatWaehrung(zinsen ) + "\t"
+ this .formatWaehrung(kapital ) + "\n" ;
+ Werkzeug.formatWaehrung(zahlung ) + "\t"
+ Werkzeug.formatWaehrung(zinsen ) + "\t"
+ Werkzeug.formatWaehrung(kapital ) + "\n" ;
jahr ++;
}
}
return kapitalentwicklung ;
}
public String formatWaehrung(double pZahl ) {
DecimalFormat decFormat = new DecimalFormat("#,##0.00" );
return decFormat .format(pZahl ) + " EUR" ;
}
}
Zinsen auf zwei Nachkommastellen runden:
nein
Math.round(double a)
Werkzeug.runden(double pZahl, int pNachkommastellen)
Geldbeträge formatiert darstellen:
nein
this.formatWaehrung(double pZahl)
Werkzeug.formatWaehrung(double pZahl)
Abb. 14-42: 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 ;
double auszahlung ;
System.out.println("Kapitalanlage mit jährlicher Ausschüttung zum Jahresbeginn" );
System.out.println("----------------------------------------------------------\n" );
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("Auszahlung p. a. (in EUR): " );
auszahlung = consoleReader .nextDouble();
System.out.println("" );
kapitalanlage = new Kapitalanlage(anfangskapital , zinssatz , auszahlung );
}
public void zeigeDaten() {
System.out.println(kapitalanlage .erstelleKapitalentwicklung());
}
}
Abb. 14-43: 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-44: Die Klasse Werkzeug
(Quellcode)
Aufgabe 14-9: Annuitätendarlehen
Erstellen Sie eine Java-Anwendung, die nach Eingabe der Darlehenssumme, des Zinssatzes und der jeweils zum Jahresende fälligen Annuität den Zins- und Tilgungsplan erstellt.
Konsole
Annuitätendarlehen
------------------
Bitte geben Sie die folgenden Informationen
zu dem gewünschten Darlehen ein:
Darlehenshöhe (in EUR): 10000
Zinssatz p. a. (in %): 8
Annuität p. a. (in EUR): 2800
Zins- und Tilgungsplan
======================
Jahr Annuität Zinsen Tilgung Restschuld
-------------------------------------------------------------
1 2.800,00 EUR 800,00 EUR 2.000,00 EUR 8.000,00 EUR
2 2.800,00 EUR 640,00 EUR 2.160,00 EUR 5.840,00 EUR
3 2.800,00 EUR 467,20 EUR 2.332,80 EUR 3.507,20 EUR
4 2.800,00 EUR 280,58 EUR 2.519,42 EUR 987,78 EUR
5 1.066,80 EUR 79,02 EUR 987,78 EUR   0,00 EUR
Abb. 14-45: Konsole mit Kapitalentwicklung (Beispieldaten)
Annuitätendarlehen
Ein Annuitätendarlehen ist ein Darlehen mit konstanten Rückzahlungsbeträgen (Raten).
Der jährlich zu zahlende und über die Laufzeit konstant bleibende Betrag wird Annuität genannt. Er setzt sich aus Zins und Tilgung zusammen. Über die Laufzeit sinkt der Anteil der Zinsen in dem Maße, wie der Anteil der Tilgung steigt, so dass die jährliche Gesamtbelastung während der gesamten Laufzeit konstant bleibt. Im letzten Jahr der Laufzeit wird der Rückzahlungsbetrag durch die Höhe der Restschuld und der hierfür anfallenden Zinsen bestimmt.
img/Abb_14_46_Annuitaetendarlehen.svg
Abb. 14-46: Annuitätendarlehen – Entwicklung von Zins- und Tilgungsanteil während der Laufzeit
Lösung
Lösung
JAVA
package app;
import java.text.DecimalFormat;
import myBib.Werkzeug;
public class Annuitaetendarlehen {
private double hoehe ;
private double zinssatz ;
private double annuitaet ;
public Annuitaetendarlehen() {
}
public Annuitaetendarlehen(double pHoehe , double pZinssatz , double pAnnuitaet ) {
this .hoehe = pHoehe ;
this .zinssatz = pZinssatz ;
this .annuitaet = pAnnuitaet ;
}
public double getHoehe() {
return hoehe ;
}
public void setHoehe(double pHoehe ) {
this .hoehe = pHoehe ;
}
public double getZinssatz() {
return zinssatz ;
}
public void setZinssatz(double pZinssatz ) {
this .zinssatz = pZinssatz ;
}
public double getAnnuitaet() {
return annuitaet ;
}
public void setAnnuitaet(double pAnnuitaet ) {
this .annuitaet = pAnnuitaet ;
}
public String berechneEntwicklung(){
String entwicklung ;
int jahr = 1;
double zinsen ;
double tilgung ;
double restschuld = this .hoehe ;
entwicklung = "Zins- und Tilgungsplan\n"
+ "====================== \n"
+ "Jahr\tAnnuität\tZinsen\t\tTilgung\t\tRestschuld\n"
+ "-------------------------------------------------------------------- \n" ;
zinsen = restschuld * zinssatz / 100;
if (annuitaet >zinsen ) {
while (restschuld >0){
zinsen = restschuld * zinssatz / 100;
zinsen = Math.round(zinsen * 100) / 100.0;
zinsen = Werkzeug.runden(zinsen , 2);
if (annuitaet > restschuld +zinsen ) {
tilgung = restschuld ;
}
else {
tilgung = annuitaet - zinsen ;
}
restschuld = restschuld - tilgung ;
entwicklung = entwicklung + jahr + "\t"
+ (tilgung +zinsen ) + "\t\t"
+ zinsen + "\t\t"
+ tilgung + "\t\t"
+ restschuld + "\n" ;
entwicklung = entwicklung + jahr + "\t"
+ this .formatWaehrung(tilgung +zinsen ) + "\t"
+ this .formatWaehrung(zinsen ) + "\t"
+ this .formatWaehrung(tilgung ) + "\t"
+ this .formatWaehrung(restschuld ) + "\n" ;
entwicklung = entwicklung + jahr + "\t"
+ Werkzeug.formatWaehrung(tilgung +zinsen ) + "\t"
+ Werkzeug.formatWaehrung(zinsen ) + "\t"
+ Werkzeug.formatWaehrung(tilgung ) + "\t"
+ Werkzeug.formatWaehrung(restschuld ) + "\n" ;
jahr ++;
}
}
return entwicklung ;
}
public String formatWaehrung(double pZahl ) {
DecimalFormat decFormat = new DecimalFormat("#,##0.00" );
return decFormat .format(pZahl ) + " EUR" ;
}
}
Zinsen auf zwei Nachkommastellen runden:
nein
Math.round(double a)
Werkzeug.runden(double pZahl, int pNachkommastellen)
Geldbeträge formatiert darstellen:
nein
this.formatWaehrung(double pZahl)
Werkzeug.formatWaehrung(double pZahl)
Abb. 14-47: Die Klasse Annuitaetendarlehen
(Quellcode)
JAVA
package ui;
import app.Annuitaetendarlehen;
public class Benutzerkonsole {
private Annuitaetendarlehen darlehen ;
public Benutzerkonsole() {
this .erfasseDarlehensdaten();
this .zeigeTilgunsplan();
}
public void erfasseDarlehensdaten(){
ConsoleReader consoleReader = new ConsoleReader();
double hoehe ;
double zinssatz ;
double annuitaet ;
System.out.println("Annuitätendarlehen" );
System.out.println("------------------\n" );
System.out.println("Bitte geben Sie die folgenden Informationen\nzu dem gewünschten Darlehen ein:\n" );
System.out.print("Darlehenshöhe (in EUR): " );
hoehe = consoleReader .nextDouble();
System.out.print("Zinssatz p. a. (in %): " );
zinssatz = consoleReader .nextDouble();
System.out.print("Annuitaet p. a. (in EUR): " );
annuitaet = consoleReader .nextDouble();
darlehen = new Annuitaetendarlehen(hoehe , zinssatz , annuitaet );
}
public void zeigeTilgunsplan(){
System.out.println("\n" + darlehen .berechneEntwicklung());
}
}
Abb. 14-48: 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-48: Die Klasse Werkzeug
(Quellcode)