F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.

24

Inhaltsverzeichnis
0 Java-Programmgerüst...................................................................................................................................... 2

1 Abkürzungsverzeichnis und wichtige Begriffe................................................................................................... 2

2 Java................................................................................................................................................................. 5

3 Compiler und Interpreter................................................................................................................................. 5

4 Datentypen...................................................................................................................................................... 5

5 Variablen und Konstanten................................................................................................................................ 6

6 Operatoren...................................................................................................................................................... 7

6.1 Arithmetische Operatoren...................................................................................................................................................................................7

6.2 Operatoren für Vergleiche...................................................................................................................................................................................8

6.3 Boolesche (logische) Operatoren.........................................................................................................................................................................8

6.4 Zuweisungsoperatoren........................................................................................................................................................................................8

6.5 Operatoren für numerische Berechnungen (Math-Klasse).................................................................................................................................9

7 Ausdrücke, Anweisungen und Zuweisungen................................................................................................... 10

7.1 Ausrücke.............................................................................................................................................................................................................10

7.2 Anweisungen......................................................................................................................................................................................................10

7.3 Zuweisungen......................................................................................................................................................................................................10

8 Typumwandlung............................................................................................................................................ 10

8.1 Automatische Typumwandlung.........................................................................................................................................................................10

8.2 Erzwungene Typumwandlung............................................................................................................................................................................10

9 Ausgaben....................................................................................................................................................... 11

9.1 Ausgabe auf der Konsole...................................................................................................................................................................................11

9.2 Ausgaben im (Konsolen-)Fenster.......................................................................................................................................................................11

9.3 Ausgabe im (grafischen) Dialogfenster..............................................................................................................................................................11

9.4 Formatierung der Ausgabe................................................................................................................................................................................11

9.4.1 Formatierung mit System.out.printf()................................................................................................................................................................................... 11

9.4.2 Formatierung mit Escape-Sequenzen................................................................................................................................................................................... 13

10 Eingaben........................................................................................................................................................ 13

10.1 Klasse Scanner..............................................................................................................................................................................................13

10.2 Eingabedialog...............................................................................................................................................................................................14

11 Darstellungsmöglichkeiten............................................................................................................................. 14

1
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

12 Übersicht über die Darstellungsformen und Algorithmen...............................................................................15

13 Kontrollstrukturen......................................................................................................................................... 16

14 Fehlerarten und Testen von Programmen....................................................................................................... 17

14.1 Fehlerarten...................................................................................................................................................................................................17

14.2 Schreibtischttest...........................................................................................................................................................................................17

14.3 Debugger......................................................................................................................................................................................................17

15 Methoden...................................................................................................................................................... 17

16 Stings als Klasse............................................................................................................................................. 20

16.1 Zeichenextraktion.........................................................................................................................................................................................20

16.2 Vergleich von Zeichenketten........................................................................................................................................................................20

16.3 Suchen in Zeichenketten..............................................................................................................................................................................21

16.4 Ersetzen von Zeichenketten.........................................................................................................................................................................21

16.5 Konvertierungsfunktionen............................................................................................................................................................................21

17 Datenstrukturen............................................................................................................................................ 22

17.1 Felder (Arrays)..............................................................................................................................................................................................22

0 Java-Programmgerüst
package Paketname;

import java.util.Scanner;

public class Dateiname

public static void main (String[] args)

Scanner input = new Scanner(System.in);

System.out.println();

1 Abkürzungsverzeichnis und wichtige Begriffe

Anweisung Einzelner Befehl oder Methodenaufruf

2
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Assembler Programmierwerkzeug, das ein in maschinennaher Assemblersprache

geschriebenes Computerprogramm in Maschinensprache übersetzt

Ausdruck Kombination von Konstanten, Operatoren, Variablen und Klammern, die verwendet
wird, um einen Wert zu berechnen

Compiler Computerprogramm, das Quellcodes einer bestimmten Programmiersprache in

eine Form übersetzt, die von einem Computer ausgeführt werden kann

Cross-Compiler Erzeugen Maschinencode für eine andere Computerplattform als die, auf der sie
selbst laufen. z.B. für Mikrocontroller

Datentyp Wertemenge mit darauf definierten Operationen

Debugger Werkzeug zum Diagnostizieren und Auffinden von Fehlern in Computersystemen

Deklaration Erzeugung einer Variablen oder Konstanten

GUI-Builder Programmierwerkzeug, welches die Erstellung grafischer Benutzeroberflächen

mittels Drag&Drop ermöglicht

IDE Integrierte Entwicklungsumgebung (Integrated Development Environment)

Initialisierung Zuweisung eines Wertes an eine Variable

JDK/SDK Entwicklungsumgebung (Java/Software Development Kit)

JRE Java-Laufzeitumgebung (Java Runtime Environment)

Klasse Beschreibt Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der

Objekte

Konstante Behälter für eine Größe, die nach der Zuweisung nicht verändert

Linker Computerprogramm das einzelne Programmmodule zu einem ausführbaren

Programm zusammenstellt (verbindet).

Loader Lädt das Programm in den Arbeitsspeicher und passt dabei alle relativen
Adressbezüge auf absolute Adressen an.

Methode Ausführbare Tätigkeit

Operator Verknüpfung von Werten um Berechnungen vorzunehmen

3
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Präprozessor Modifiziert vor dem eigentlichen Kompilieren den Quellcode. Mit seiner Hilfe
werden weitere Quelltextdateien eingebunden, Teile des Codes ignoriert oder
ersetzt.

Quelltext Für Menschen lesbarer, in einer Programmiersprache geschriebener Text eines

Computerprogrammes

Schlüsselwörter Vorbelegte Worte in der Sprache Java

Semantik definiert, was ein geschriebenes Programm tun wird

Syntax definiert, wie ein Programm geschrieben werden darf

Typumwandlung Werden Werte mit verschiedenen Datentypen miteinander durch einen Operator
verknüpft, so muss das Ergebnis einem der beiden Datentypen entsprechen. Dazu
muss der Datentyp einer der beiden Variablen umgewandelt werden.

UML Unified Modelling Language

Variable Speicherzelle, die über einen Namen (den Bezeichner) angesprochen wird.

Zuweisung Anweisung, bei der mit Hilfe des Zuweisungsoperators = der Wert des rechts vom
Gleichheitszeichen stehenden Ausdruckes der linken Seite, meist eine Variable,
zugewiesen wird

4
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

2 Java
Zur Java-Technik gehören die folgenden Bestandteile:

 die Programmiersprache Java, um Programme zu formulieren

 das Java Development Kit (JDK) – ein Entwicklungswerkzeug, das grundlegende Teile wie einen
Übersetzer und Bibliotheken enthält
 die Java Runtime Environment (JRE) – die Java-Laufzeitumgebung ist eine standardisierte Software-
Plattform, um die entwickelten Programme ausführen zu können.
 Die Java Virtual Machine (JVM) - ist der Teil der Java-Laufzeitumgebung. Das gestartete Java-
Programm wird in einer eigenen virtuellen Maschine (VM) ausgeführt. Die JVM dient dabei als
Schnittstelle zur Maschine und zum Betriebssystem und ist für die meisten Plattformen verfügbar.

3 Compiler und Interpreter

Der Quelltext an sich ist nicht direkt ausführbar, denn der Computer benötigt das Programm in „seiner"
Sprache, der Maschinensprache. Es ist daher erforderlich, dass der Quelltext von der für Menschen
lesbaren Form durch den Compiler oder Interpreter in eine für eine Maschine ausführbare Form übersetzt
wird.

Compiler Interpreter
Vollständige Übersetzung des Quelltextes vor der Zeilenweise Übersetzung des
Ausführung des Programmes durch einen Compiler in Programmes während seiner Ausführung durch einen
Maschinensprache. Interpreter.

4 Datentypen
Typnam Größe Wertebereich Beschreibung
e
boolean undefiniert true / false Boolescher Wahrheitswert, Boolescher Typ
char 16 bit 0 ... 65.535 (z. B. 'A') Unicode-Zeichen (UTF-16)
byte 8 bit -128 ... 127 Zweierkomplement-Wert
short 16 bit -32.768 ... 32.767 Zweierkomplement-Wert
int 32 bit -2.147.483.648 ... 2.147.483.647 Zweierkomplement-Wert
long 64 bit -263 bis 263-1, ab Java 8 auch 0 bis Zweierkomplement-Wert
264 -1
float 32 bit +/-1,4E-45 ... +/-3,4E+38 32-bit IEEE 754, es wird empfohlen, diesen Wert

5
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

nicht für Programme zu verwenden, die sehr genau

rechnen müssen.
double 64 bit +/-4,9E-324 ... +/-1,7E+308 64-bit IEEE 754, doppelte Genauigkeit

5 Variablen und Konstanten

Eine Variable ist letztlich eine Art Namen für eben diesen Speicherplatz.

Konstanten können wie Variablen im Programm angesprochen werden, verändern aber während des
Programmlaufes ihren Wert nicht. Wird dies trotzdem versucht, reagiert der Compiler mit einer
Fehlermeldung. Konstanten werden üblicherweise in Großbuchstaben geschrieben.

Die Erzeugung einer Variablen oder Konstanten, bezeichnet man als Deklaration. Hierfür wird ein Datentyp
und ein Bezeichner (Variablenname) benötigt. Der benötigte Speicherplatz wird mit der Deklaration anhand
des Datentyps reserviert.

Abbildung 1: Variablendeklaration

Namen müssen mit einem Buchstaben beginnen und dürfen weitere Buchstaben, Ziffern und den
Unterstrich _ enthalten. Die Groß- und Kleinschreibung wird beachtet, name, Name und NAME sind also 3
verschiedene Variablen. Leerzeichen sind in Variablennamen nicht erlaubt.

Es existiert eine Namenskonvention, die Regeln für die Bildung von Variablennamen vorschlägt. Sie sollten
sich an diese Konvention nach Möglichkeit halten.

 Variablenbezeichner beginnen immer mit einem Kleinbuchstaben

 Keine Ziffer als erstes Zeichen im Variablennamen erlaubt
 Keine Schlüsselwörter der Programmiersprache erlaubt (class, public, void, int, ...)
 Variablenbezeichner sollten möglichst aussagekräftig sein ( "sprechende" Variablennamen)
 besteht ein Variablenbezeichner aus mehreren zusammengesetzten Wörtern, so beginnt jedes
Wort (außer dem ersten) mit einem Großbuchstaben (Camel-Case)

Die erstmalige Zuweisung eines Wertes an eine Variable wird als Initialisierung bezeichnet. Sie kann
zusammen mit der Deklaration oder getrennt davon erfolgen. Die Initialisierung einer Variablen kann durch
jeden Ausdruck erfolgen, der einen passenden Wert liefert. Finden Deklaration und Initialisierung

6
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

gemeinsam statt, können mehrere Variablen desselben Typs gleichzeitig in einem Ausdruck deklariert
werden.

6 Operatoren
Rangfolge Typ Operatoren
1 Postfix-Operatoren, Postinkrement, Postdekrement x++, x--
2 Einstellige (unäre) Operatoren, Vorzeichen ++x, --x, +x, -x, ~b, !b
3 Multiplikation, Teilerrest a*b, a/b, a % b
4 Addition, Subtraktion a + b, a - b
5 Bitverschiebung d << k, d >> k, d >>> k
6 Vergleiche a < b, a > b, a <= b, a >= b, s instanceof S
7 Gleich, Ungleich a == b, a != b
8 UND (Bits) b&c
9 Exor (Bits) b^c
10 ODER (Bits) b|c
11 Logisch UND B && C
12 Logisch ODER B || C
13 Bedingungsoperator a?b:c
a = b, a += 3, a -= 3, a *= 3, a /= 3, a %= 3, b &=
14 Zuweisungen
c, b ^= c, b |= c, d <<=k, d >>= k, d >>>= k

6.1 Arithmetische Operatoren

Operator Beschreibung Kurzbeispiel
+ Addition int antwort = 40 + 2;
- Subtraktion int antwort = 48 - 6;
* Multiplikation int antwort = 2 * 21;
/ Division int antwort = 84 / 2;
% Teilerrest, Modulo-Operation, errechnet den Rest einer Division int antwort = 99 % 57;
+ positives Vorzeichen, in der Regel überflüssig int j = +3;
- negatives Vorzeichen int minusJ = -j;

Für zwei besonders in Schleifen häufig anzutreffende Berechnungen gibt es eine abkürzende Schreibweise.

Operator Beschreibung Kurzbeispiel

++ Postinkrement, Addiert 1 zu einer numerischen Variable x++;
++ Preinkrement, Addiert 1 zu einer numerischen Variable ++x;
-- Postdekrement, Subtrahiert 1 von einer numerischen Variable x--;
-- Predekrement, Subtrahiert 1 von einer numerischen Variable --x;

Post- und Pre-Operatoren verhalten sich bezüglich ihrer Berechnung absolut gleich, der Unterschied ist der
Zeitpunkt, wann die Operation ausgeführt wird. Zum Tragen kommt das bei Zuweisungen:

i = 1;
a = ++i; // i = 2 und a = 2 (erst hochzählen, dann zuweisen)
7
i = 1;
b = i++; // i = 2 und b = 1 (erst zuweisen, dann hochzählen)
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

6.2 Operatoren für Vergleiche

Das Ergebnis dieser Operationen ist aus der Menge true, false.

Operator Beschreibung Kurzbeispiel

== gleich 3 == 3
!= ungleich 4 != 3
> größer als 4>3
< kleiner als -4 < -3
>= größer als oder gleich 3 >= 3
<= kleiner als oder gleich -4 <= 4

6.3 Boolesche (logische) Operatoren

Das Ergebnis dieser Operationen ist aus der Menge true, false.

Operator Beschreibung Kurzbeispiel

! Negation, invertiert den Ausdruck boolean lügnerSpricht = !wahrheit;
&& Und, true, genau dann, wenn alle boolean krümelmonster = istBlau && magKekse;
Argumente true sind
|| Oder, true, wenn mindestens ein Operand true ist boolean machePause = hungrig || durstig;
^ Xor, true wenn genau ein Operand true ist boolean zustandPhilosoph = denkt ^ ist;

6.4 Zuweisungsoperatoren
Operator Bezeichnung Beispiel Beschreibung
Es wird a der Wert von b zugewiesen und b als
= Einfache Zuweisung a=b
Rückgabewert geliefert.
Es wird a das Ergebnis aus a + b zugewiesen
+= Additionszuweisung a += b
und a + b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a – b zugewiesen
-= Subtraktionszuweisung a -= b
und a – b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a * b zugewiesen
*= Multiplikationszuweisung a *= b
und a * b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a / b zugewiesen
/= Divisionszuweisung a /= b
und a / b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a % b zugewiesen
%= Modulozuweisung a %= b
und a % b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a | b zugewiesen
|= Oder-Zuweisung a |= b
und a | b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a ^ b zugewiesen
^= Exklusiv-Oder-Zuweisung a ^= b
und a ^ b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a << b zugewiesen
<<= Linksschiebe-Zuweisung a <<= b
und a << b als Rückgabewert geliefert.
Es wird a das Ergebnis aus a >> b zugewiesen
>>= Rechtsschiebe-Zuweisung a >>= b
und a >> b als Rückgabewert geliefert.
>>>= Rechtsschiebe-Zuweisung a >>>= b Es wird a das Ergebnis aus a >>> b zugewiesen

8
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

ohne Vorzeichen

6.5 Operatoren für numerische Berechnungen (Math-Klasse)

Die Klasse Math ist das Matheobjekt mit allen Operationen für einfache numerische Berechnungen. Neben
Konstanten PI und E werden auch viele mathematische Operationen wie Wurzelziehen, Exponentialzahlen,
Sinus und Cosinus zur Verfügung gestellt. Alle Konstanten und Methoden in der Math-Klasse sind static,
damit man kein eigenes Math-Objekt für jede Berechnung anlegen muss. Der Ergebnistyp fast aller
Operationen ist double. Dazu die unterschiedlichen Methoden und was sie machen:

Konstanten: PI, E

double wert = Math.PI;

Wurzelziehen, Logarithmus und Exponentialfunktion: sqrt, log, pow

double x = Math.sqrt(2);

double y = Math.pow(2,10); // 2^10 = 1024

Trigonometrische Funktionen: sin, cos, acos, asin, atan, atan2

double wert = Math.sin(0.0);

double wert2 = Math.sin(Math.PI);

Minimum und Maximum: min, max

int x = Math.min(2,4); //Ergebnis ist 2

int y = Math.max(2,4); //Ergebnis ist 4

Absolutwert, Runden und Abschneiden: abs, ceil, floor, rint, round

double x = Math.abs(-4.1); //Ergebnis ist 4.1

int y = Math.round(4.2); //Ergebnis ist 4

Umrechnung Grad (0..360) in Radian (0..2*PI)

x = Math.toDegrees(Math.PI);

y = Math.toRadians(90);

Pseudozufallswert ausgeben aus dem Bereich von größer oder gleich 0.0 bis kleiner 1.0

9
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

double x =
Math.random();

7 Ausdrücke, Anweisungen und Zuweisungen

7.1 Ausrücke
Ein Ausdruck ist eine Kombination von Konstanten, Operatoren, Variablen und Klammern, die verwendet
wird, um einen Wert zu berechnen. Ausdrücke enthalten Operatoren und Operanden. Ein Operand ist ein
Wert, auf den ein Operator einwirkt.

7.2 Anweisungen
Unter einer Anweisung oder einem Statement versteht man in der Programmierung einen einzelnen Befehl
oder Methodenaufruf. Anweisungen haben, ganz im Gegensatz zu Ausdrücken, nicht immer einen Wert.
Eine Anweisung wird immer mit einem Semikolon abgeschlossen.

7.3 Zuweisungen
Eine Zuweisung ist ebenfalls eine Anweisung, bei der mit Hilfe des Zuweisungsoperators = der Wert des
rechts vom Gleichheitszeichen stehenden Ausdruckes der linken Seite, meist einer Variable, zugewiesen
wird. Bei Zuweisungen wir immer zuerst die rechte Seite (rechts vom Gleichheitszeichen) vollständig
abgearbeitet und ausgewertet (berechnet), und dann erst wird dieses Ergebnis der linken Seite zugewiesen.

8 Typumwandlung
8.1 Automatische Typumwandlung
Die Typumwandlung wird vom Compiler / Interpreter automatisch durchgeführt, wenn dadurch kein
Informationsverlust zu erwarten ist. So geht bei einer Umwandlung einer Variablen vom Datentyp int nach
double keine Information verloren.

8.2 Erzwungene Typumwandlung

Das Problem kann u.a. durch eine erzwungene Typumwandlung (expliziter Typecast) gelöst werden.

Eine Typumwandlung kann vom Programmierer erzwungen werden, indem der Zieldatentyp in runden
Klammern vor den Variablennamen geschrieben wird.

int zaehler = 5; int b1 = 5;

int nenner = 4; double b2 = 3.3;
double quotient; int summe = b1 + (int) b2;
quotient = (double) zaehler / nenner;

10
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

9 Ausgaben
9.1 Ausgabe auf der Konsole
Ausgaben auf die Konsole erreicht man mit dem Befehl System.out.println(). Der auszugebende Inhalt wird
in die Klammern geschrieben. Es können alle Arten von Zeichen und Zahlen ausgegeben werden.

System.out.println("Hallo Welt."); // Gibt den Text Hallo Welt. auf der Konsole aus.

System.out.println(a); // Gibt den Wert der Variablen a auf der Konsole aus.

System.out.println(); // Erzeugt eine leere Zeile auf der Konsole.

System.out.println(7+23/(3*12)); // gibt das Ergebnis des Ausdruckes / der Rechnung an.

Zeichenketten (Strings) können mit dem "+" - Operator verknüpft (oder verkettet) werden.

a = "Peter ";

b = "Lustig.";

System.out.println( a + b );

Sie können auf diese Weise auch Texte, Stringvariablen und beliebige andere Variablen konkatenieren.

System.out.println(“Das Ergebnis: “ + x); //Verkettung mit Variablen

9.2 Ausgaben im (Konsolen-)Fenster

1. import ch.aplu.util.*; //Bibliothek importieren

2. Console.print(“Hallo Welt“); //Zeichenketten ausgeben

9.3 Ausgabe im (grafischen) Dialogfenster

1. import javax.swing.JOptionPane; //Bibliothek importieren

2. JOptionPane.showMessageDialog(null, "Meldungstext", "Titel" //Zeichenketten ausgeben

JOptionPane.PLAIN_MESSAGE)

9.4 Formatierung der Ausgabe

9.4.1 Formatierung mit System.out.printf()
Die printf()-Methode wird üblicherweise verwendet, um die Ausgabe zu formatieren. Wichtig: printf()
beendet Zeilen nicht mit einem Zeilenumbruch (wie println() ). printf() erfordert mindestens einen
Parameter vom Typ String, der oft auch als Formatbeschreiber oder „Formatierungsstring” bezeichnet wird.

11
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Jeder Formatierungsausdruck besteht aus einem Prozentzeichen (%), dem die eigentliche
Formatbeschreibung folgt, z.B. %3d für die 3-stellige Ausgabe einer Ganzzahl. Der Formatierungsausdruck
hat folgende allgemeine Form (die Einträge in den eckigen Klammern sind optional):

%[Schalter][Breite][.Genauigkeit]Typ

Die optionalen Schalter verändern das Format der Ausgabe:

- : Ausgabe wird links ausgerichtet (default ist rechts)

+ : bei numerischen Werten ein Vorzeichen ausgeben
0 : nach links mit führenden Nullen auffüllen (default ist Leerzeichen)
, : Komma als Tausendertrennzeichen verwenden (bei Zahlen >= 1000)
: Leerzeichen, Vorzeichen nur bei negativen Werten, sonst Leerzeichen

Die optionale Breite ist eine nicht-negative Ganzzahl, welche die Mindestanzahl der insgesamt
ausgegebenen Zeichen bestimmt.

Mit der optionalen Genauigkeit wird üblicherweise die Anzahl der ausgegebenen Zeichen nach dem Komma
eingeschränkt. Es wird gerundet.

Typ Beschreibung
s Der zugehörige Parameter wird als String ausgegeben
S Der zugehörige Parameter wird als String in Großbuchstaben ausgegeben
D Der zugehörige Parameter wird als Ganzzahl ausgegeben
f Der zugehörige Parameter wird als Dezimalzahl (mit Nachkommastellen) ausgegeben.

Beispielanweisung Ausgabe auf der Konsole

System.out.printf("Text");
a) TextX
System.out.printf("X");

b) System.out.printf("%d\n", 12); 12

int x = 12;
c) X= 12, Y=12345
System.out.printf("X=%3d, Y=%3d\n", x, 12345);

double y=1234.1254567890;
System.out.printf("A:%f\n", y); A:1234,125457
d) System.out.printf("B:%5.2f\n", y); B:1234,13
System.out.printf("C:%12.5f\n", y); C: 1234,12546
System.out.printf("D:%12.6f\n",y); D: 1234,125457

String gs = "gross";
e) double d = 1.9; ! 1,9m ist GROSS!
System.out.printf("!%4.1fm ist %7S!\n", d, gs);

12
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

9.4.2 Formatierung mit Escape-Sequenzen

Die Ausgabe lässt sich auch mit sog. Escape-Sequenzen steuern. Dabei handelt es sich um spezielle Zeichen,
die im auszugebenden String enthalten sind und besondere Steuerzeichen darstellen. In Java gibt es die
folgenden Escape-Sequenzen.

Sequenz Bedeutung
\b Rückschritt (Backspace)
\t Horizontaler Tabulator
\n Zeilenschaltung (Newline)
\f Seitenumbruch (Formfeed)
\r waagenrücklauf (Carriage return)
\" Doppeltes Anführungszeichen
\' Einfaches Anführungszeichen
\\ Backslash
\nnn Oktalzahl nnn
\uXXXX Unicode XXXX (hexadezimal)

Mit Hilfe der Escape-Sequenzen können Sie also auch " auf die Konsole schreiben. Normalerweise beginnt
oder endet ein String ja mit einem ", was die Ausgabe dieses Zeichen verhindern würde. Man nennt diesen
Vorgang auch "maskieren".

System.out.println("Er sagte: \"Ich habe nichts zu verbergen.\" und schwieg danach.");

10 Eingaben
10.1 Klasse Scanner
Im Paket java.util steht die Klasse Scanner zur Verfügung. Mit ihrer Hilfe ist das Einlesen über die Tastatur
(auch Standardeingabe genannt), inklusive einer Umwandlung in den gewünschten Datentyp (int, double)
einfach möglich.

Übersicht über die Befehle

1. import java.util.Scanner; //Bibliothek importieren

2. Scanner input = new Scanner(System.in); //Scannerobjekt erzeugen
3. int n = input.nextInt(); //Integerwerte einlesen
double d = input.nextDouble(); //Fließkommazahlen einlesen
String s = input.nextLine(); //Zeichenketten einlesen

13
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

10.2 Eingabedialog
Eingabefenster lassen sich mit Hilfe der swing-Klasse JOptionPane erzeugen. In der einfachsten Form stellt
die Klasse die mehrfach überladene Methode showInputDialog() bereit, mit der das gewünschte Fenster
erzeugt und wunschgemäß konfiguriert werden kann.

Übersicht über die Befehle

1. import ch.aplu.util.*; //Bibliothek importieren

2. InputDialog id = new InputDialog(_Titel_,_Meldung_); //Eingabedialog erzeugen
3. int n = id.readInt(); //Integerwerte einlesen
double d = id.readDouble(); //Fließkommazahlen einlesen
String s = id.readString(); //Zeichenketten einlesen

11 Darstellungsmöglichkeiten
Viele Problemstellungen sind umfangreich und kompliziert, daher erfordern sie eine systematische
Vorgehensweise zur Erarbeitung der Lösung. Der Entwurf eines Programms kann
programmiersprachenunabhängig mit grafischen Darstellungsmitteln erfolgen.

Darstellungsmöglichkeiten

 Struktogramm
 PAP (Programmablaufplan)
 Pseudocode
 etc.

14
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

12 Übersicht über die Darstellungsformen und Algorithmen

Strukturelement Pseudocode Struktogramm Programmablaufplan
Verarbeitung
Anweisung
(Elementarblock)

Anweisung1
Reihenfolge
Anweisung2
(Sequenz)
Anweisung3

Wenn Bedingung
Dann Anweisung

Verzweigung
(Alternative)

Wenn Bedingung
Dann Anweisung 1
Sonst Anweisung 2

Für Variable
Wert 1:
Anweisung 1
Fallunterscheidung Wert 2:
Anweisung 2
…
[sonst Anweisung]

Von
Zähler:=Startwert
Zählschleife
Bis Endwert
Anweisung

Anfangsgeprüfte
Schleife oder Solange Bedingung
kopfgesteuerte Anweisung
Schleife

Endgeprüfte Schleife Wiederhole

oder fußgesteuerte Anweisung
Schleife Bis Bedingung

15
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

13 Kontrollstrukturen
Drei grundlegende Kontrollstrukturen reichen aus, um alle berechenbare Programme zu implementieren:

16
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

14 Fehlerarten und Testen von Programmen

14.1 Fehlerarten
 Syntaxfehler (Syntax error)
 Laufzeit-Fehler (Runtime error)
 Logische Fehler / Designfehler

14.2 Schreibtischttest
Den Schreibtischtest führt man nicht im Computer durch, sondern mit dem Kopf, Bleistift und Papier. Man
legt sich eine Liste aller Variablen an, wählt Eingangswerte, zu denen man die Ergebnisse, die der
Algorithmus liefern soll, bereits kennt und geht dann Schritt für Schritt durch das Programm und prüft, ob
das Ergebnis mit den Erwartungen übereinstimmt. Bei dieser Vorgehensweise kann man oft erkennen, an
welcher Stelle das Programm falsch ist.

14.3 Debugger
Computerprogramm, das das Aufspüren und Diagnostizieren von Fehlern in Computersoftware ermöglicht.
Ziel eines solchen Hilfswerkzeugs ist es, die Funktionalität der überprüften Software auf allen anvisierten
Geräten und Plattformen langfristig zu gewährleisten.

15 Methoden
Kleinere Programmieraufgaben lassen sich noch leicht innerhalb der main-Funktion realisieren, größere
Projekte mit mehreren hundert oder tausend Anweisungen werden aber Sinnvollerweise in kleinere Teile
(Unterprogramme, Funktionen) zerlegt. Komplexe Programmieraufgaben werden so mittels Funktionen in
kleinere, einfachere Teile aufgespaltet. Die Programmteile werden bei der Programmerstellung "bottom
up" erzeugt, d.h. zuerst werden die einzelnen Funktionen geschrieben, die anschließend zum
Gesamtprogramm zusammengefügt werden.

Idee hinter Methoden

 beliebig viele Programmzeilen zu einem Anweisungsblock zusammenfassen

 diesem Block einen Namen geben
 den Block über seinen Namen aufrufen

Vorteil:

 Änderungen sind viel einfacher durchführbar

 Programm wird übersichtlicher

17
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Allgemeine Syntax einer Methodendefinition

[Sichtbarkeit] [Schlüsselwort] Typ_des_Rückgabewertes Methodenname ([Parameterliste]) {

[Anweisungen;]

[] sind optionale Angaben.

Sichtbarkeit public

Die Sichtbarkeit public sagt aus, dass jeder diese Methode benutzen darf. Sie ist für die main()-Methode
zwingend erforderlich, da sonst ein Java-Programm nicht mehr ausführbar ist. Bei den Grundlagen der
Objektorientierung werden wir noch genauer auf die Sichtbarkeiten eingehen.

Schlüsselwort static

Das Schlüsselwort static bewirkt, dass die Methode direkt über den Klassennamen aufrufbar ist, ohne das
ein Objekt der Klasse erzeugt werden muss. Weißt den Compiler an, die Methode in den Arbeitsspeicher zu
laden, damit sie bei ihrem Aufruf ohne weitere Vorarbeiten ausgeführt werden kann. Alle Programmteile
(wie Variablen, Methoden usw.), die in der main()-Methode ausgeführt werden sollen, müssen sich im
Arbeitsspeicher befinden. Hierzu dient (bis auf weiteres) das Schlüsselwort static. Näheres dazu auch im
Abschnitt der Objektorientierung.

Typ des Rückgabewertes

 Vor dem Methodennamen steht der Typ des Rückgabewertes einer Methode.
 Mit dem Schlüsselwert void kann hier festgelegt werden, dass die Methode keinen Rückgabewert
hat.
 Methoden ohne Rückgabewerte können direkt aufgerufen werden.
 Als Typ des Rückgabewertes ist neben void jeder gültige Daten- oder Objekttyp möglich
 Soll eine Methode einen Rückgabewert liefern, so muss der Datentyp des zu erwartenden
Ergebnisses definiert sein. Die letzte Anweisung muss ein return-Befehl sein, an den sich das
Ergebnis der Methode anschließt.

Der Rückgabewert einer Methode wird nach deren Ausführung einer Variablen zugewiesen. (siehe Beispiel
Methoden mit Rückgabewert)

18
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Methodenname

Sie beginnen meist mit einem Kleinbuchstaben und sollten einen möglichst sprechenden Namen haben. Es
folgt ein Paar runde Klammern für die Übergabeparameter. Hat die Methode keine Übergabeparameter so
wie im Beispiel, dann bleiben die Klammern einfach leer.

Parameterliste bzw. Übergabeparameter

Benötigt eine Methode zur Erledigung ihrer Aufgabe bestimmte Informationen, so werden dafür
Übergabeparameter definiert. Diese werden mit Angabe des Datentyps in die runden Klammern nach dem
Methodennamen eingefügt. Mehrere Übergabeparameter werden durch ein Komma getrennt. Die
Übergabeparameter können nur innerhalb der der Methode verwendet werden, in der sie deklariert
wurden. Solche Übergabeparameter werden auch formale Parameter genannt.

Übersicht Methoden

19
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

16 Stings als Klasse

16.1 Zeichenextraktion
Methode char charAt(int index);
Liefert das Zeichen an Position index. Dabei hat das erste Element eines Strings den Index
Bedeutung 0 und das letzte den Index length()-1. Falls der String kürzer als index + 1 Zeichen ist, wird
eine Ausnahme des Typs StringIndexOutOfBoundsException erzeugt.
char c;
Beispiel c = s.charAt(8); // c enthält den Buchstaben M

Methode String substring(int begin, int end);

Liefert den Teilstring, der an Position begin beginnt und an Position end endet. Wie bei
Bedeutung allen Zugriffen über einen numerischen Index beginnt auch hier die Zählung bei 0. Hinweis:
end zeigt auf das erste Zeichen hinter dem zu extrahierenden Teilstück.
String sx;
Beispiel sx = s.substring(8, 13); //sx enthält das Wort „Mauer“

Methode String trim()

Liefert den String, der entsteht, wenn auf beiden Seiten der Zeichenkette jeweils alle
zusammenhängenden Leerzeichen entfernt werden. Dabei werden alle Zeichen, die
Bedeutung
einen Code kleiner gleich 32 haben, als Leerzeichen angesehen. trim entfernt immer die
Leerzeichen auf beiden Seiten.
Beispiel

Methode int length()

Liefert die aktuelle Länge des String-Objekts. Ist der Rückgabewert 0, so bedeutet dies,
Bedeutung dass der String leer ist. Wird ein Wert n > 0 zurückgegeben, so enthält der String n
Zeichen, die an den Indexpositionen 0 bis n - 1 liegen.
int n;
Beispiel n = s.length(); //n = 52

16.2 Vergleich von Zeichenketten

Methode boolean equals(Object anObject):
Liefert true, wenn das aktuelle String-Objekt und anObject identisch sind. Es wird auf
Bedeutung
inhaltliche Gleichheit geprüft.
boolean b;
Beispiel b = s.equals(“Auf der Mauer“); //b ist danach = false

20
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Methode boolean startsWith(String sx);

http://www.addison-wesley.de/service/krueger/kap11002.htm
Methode boolean endsWith(String sx);
http://www.addison-wesley.de/service/krueger/kap11002.htm
Methode int compareTo(String sx);
http://www.addison-wesley.de/service/krueger/kap11002.htm

16.3 Suchen in Zeichenketten

Methode int indexOf(String sx);
sucht nach dem ersten Vorkommen von sx in s und liefert den Index des ersten Zeichens
Bedeutung
der Übereinstimmung zurück, andernfalls -1.
int n;
Beispiel n = s.indexOf(“Mauer“); //n = 8

16.4 Ersetzen von Zeichenketten

Methode String toLowerCase();
Bedeutung Wandelt alle Zeichen im String in Kleinbuchstaben um.
String sx;
Beispiel sx = s.toLowerCase(); //sx = „auf der mauer, auf der lauer...

Methode String toUpperCase();

Bedeutung Wandelt alle Zeichen im String in Großbuchstaben um..
String sx;
Beispiel sx = s.toUpperCase(); //sx = „AUF DER MAUER, AUF DER LAUER...

Methode String replace(char oldchar, char newchar);

Bedeutung Ersetzt jedes Auftreten des Zeichens oldchar im String durch newchar
String sx;
Beispiel sx = s.replace('u','x'); //sx = „Axf der Maxer, axf der...

16.5 Konvertierungsfunktionen
String valueOf(boolean b);
String valueOf(char c);
Methode
String valueOf(double d);
String valueOf(int i);
Diese Methoden wandeln primitive Datentypen in Zeichenketten um. Neben den hier
Bedeutung genannten gibt es noch einige mehr. Es handelt sich um sogenannte Klassenmethoden
(dazu später mehr).
String sx
Beispiel sx = String.valueOf(42); //sx = „42“

21
 F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

17 Datenstrukturen
17.1 Felder (Arrays)
Syntax der Deklaration:

Typ[] Name = new Typ[Anzahl];

Typ Name[] = new Typ[Anzahl];

Beispiele (eindimensionales Array):

Füllen von Arrays

int[] mit Nullen
array1 = new int[10];

Beispiel: eindimensionales Array

int array2[] = new int[20];

int[] feld = new int[6];

Beispiel //Deklaration
(zweidimensionales Array):

for (int i=0;int

i<6; i++){
array3[][] = //Initialisierung
new int[5][4];

feld[i] = 0;

Beispiel: zweidimensionales Array

int[][] feld = new int[6][4]; //Deklaration

for (int i=0; i<6; i++){ //Initialisierung

for (int j=0; j<4; j++){

feld[i][j] = 0;

Füllen von zweidimensionalen Arrays

22
F. Schneider Zusammenfassung Strukturiert Programmieren mit Java 10.08.24

Die Klasse java.util.Arrays

import java.util.Arrays;

int[] meinArray = {5, 2, 1, 4, 3};

// Array in String zurückliefern

System.out.println(Arrays.toString(meinArray)); // [5, 2, 1, 4, 3]

// Array sortieren

Arrays.sort(meinArray); // 1, 2, 3, 4, 5

// Binäre Suche

Arrays.binarySearch(meinArray, 1); // 0

// Array füllen

Arrays.fill(meinArray, 1); // 1, 1, 1, 1, 1

// Array kopieren

int[] kopie = Arrays.copyOf(meinArray, meinArray.length);

// Arrays vergleichen

Arrays.equals(meinArray, kopie); // true

23