Arrays 3

Werbung
Grundlagen der
Programmierung –Teil1
Einheit III - 22. Okt. 2010
GDP
DDr. Karl D. Fritscher
basierend auf der Vorlesung
“Grundlagen der Programmierung”
von
DI Dr. Bernhard Pfeifer
Einschub
Bevor wir mit den „Anweisungen“ fortfahren, folgt
zuerst ein kleiner Einschub/Nachtrag zum Thema:
• Arrays
Arrays
• Arrays sind eine Reihung/Auflistung von Elementen eines festen Grundtyps.
• Arrays sind semidynamisch - d.h. ihre Größe wird zur Laufzeit (=d.h.
während der ein Programm von einem Rechner ausgeführt wird) festgelegt,
kann jedoch im Nachhinein nicht mehr geändert werden.
An dieser Stelle wieder einmal ein kleiner Ausblick:
• Arrays sind in Java im Grunde genommen Objekte. Obwohl dies bei der
Benutzung kaum auffällt hat dies folgende Konsequenzen :
 Array Variablen sind Referenzen
 Arrays besitzen Instanz-Variablen und Methoden
 Arrays werden erst zur Laufzeit erzeugt
Arrays 2
• Ein Array wird in Java wie folgt deklariert
 Deklaration der Array-Variablen
 Erzeugen eines Arrays und Zuweisung an die Array-Variable
• Die Deklaration entspricht dabei syntaktisch der einer einfachen
Variable, mit dem Unterschied, dass am Typnamen eckige Klammern
angehängt werden
int[] a;
double[] b;
• Die eckigen Klammern können theoretisch auch hinter dem Variablennamen geschrieben werden (eher unkonventionell)
71
Arrays 3
•
Bei der Erzeugung eines Arrays mit n Elementen werden die Elemente
von 0 bis n-1 durchnummeriert
Erzeugung eines int-Arrays mit 3 Elementen
int[] a
= new int[3];
oder
int[] a = {1, 5, 3};
Zugriff auf Arrayelemente 1
•
Der Zugriff auf die Elemente erfolgt dabei über den numerischen Index,
der nach der Arrayvariable in eckigen Klammern angegeben wird
public class ArrayTest
{
public static void main (String[] args)
{
int[] values = new int[10];
values[0] = 20;
System.out.println (“Erstes Element: “ + values[0]);
System.out.println (“Zweites Element: “ + values[1]);
}
Ausgabe ??
}
Zugriff auf Arrayelemente 2
values ai
20
15
2
44
77
12
2
9
0
1
index i
0
1
2
3
4
5
6
7
8
9
public class ArrayTest2
{
public static void main (String[] args)
{
int[] values
= {20,15,2,44,77,12,2,9,0,1};
}
System.out.println
(“Erstes Element: “ + values[0]);
}
System.out.println (“Zweites Element: “ + values[1]);
}
Ausgabe ??
}
Mehrdimensionale Arrays
• Mehrdimensionale Arrays werden erzeugt, indem zwei oder mehr Paare
eckiger Klammern bei der Deklaration angegeben werden.
• Mehrdimensionale Arrays werden als Arrays von Arrays angelegt.
• Die Initialisierung erfolgt analog zu eindimensionalen Arrays.
Beispiel:
int [][] twodim = new int[3][2];
i/j
0
1
0
0
0
1
0
0
2
0
0
Anzahl Zeilen Anzahl Spalten
74
Switch- Anweisung
Für eine Mehrfachselektion, d.h. eine Selektion mit mehreren Alternativen
kann die switch-Anweisung verwendet werden:
• Syntax
switch (ausdruck)
{
case constant :
anweisung;
……
break;
case constant :
………
default :
………
}
•
Die mit dem Wortsymbol case
eingeleiteten Konstanten mit nachfolgendem Doppelpunkt legen dabei so
genannte Einsprungmarken für den
Programmablauf fest.
•
Zwischen
dieses
Einsprungsmarken
müssen nicht unbedingt Anweisungen
stehen.
Außerdem sind auch die
Abbruchanweisung (break) sowie die
Marke default und die nachstehenden
Anweisungen optional.
82
Switch-Anweisung 2
• Syntax
switch (ausdruck)
{
case constant :
anweisung;
……
break;
case constant :
………
default :
………
}
Es handelt sich im switch Block um eine Folge von
Anweisungen, von denen einige als Einsprungsmarken
definiert sind.
Es wird zunächst der Ausdruck ausgewertet, dessen
Ergebnistyp byte, short, int oder char (auch
enum ist erlaubt) sein muss.
Daraufhin wird der Programmablauf genau an der caseMarke fortgesetzt, die mit der Auswertung
übereinstimmt. Es wird der Code ausgeführt, bis auf
eine break Anweisung gestoßen wird. Die break
Anweisung bewirkt, dass die switch Anweisung
verlassen wird.
Wird keine passende case Konstante gefunden, so
wird bei der default Marke (sofern vorhanden)
fortgesetzt.
82
Switch-Anweisung 3
b = 5;
???
a
b
1
20
2
20
3
20
4
40
5
0
83
Schleifen
•
In Java gibt es drei verschiedene Schleifenanweisungen. Diese werden wie
folgt bezeichnet:
 abweisende Schleife (while-Schleife)
 nichtabweisende Schleife (do-while-Schleife)
 Zählschleife (for-Schleife)
84
While-Schleife
• Die while Schleife
while (ausdruck)
anweisung;

Zuerst wird der Ausdruck, der vom Typ boolean sein muss
ausgewertet. Ist er true, wird die Anweisung ausgeführt, andernfalls wird
mit der ersten Anweisung hinter der Schleife weitergemacht.

Nachdem die Schleifenanweisung ausgeführt wurde, wird der Ausdruck
erneut geprüft usw.
85
While-Schleife
• Die while Schleife
while (ausdruck)
anweisung;
public class WhileSchleife
{
public static void main(String args[])
{
int i=0;
while (i<10) // Solange i < 10 …
{
i=i+1;
System.out.println("Die Zahl ist: " + i);
}
}
}
85
do-while-Schleife
• Die do-while-Schleife
do
anweisung;
while(ausdruck);

Die do-while-Schleife arbeitet nichtabweisend. Dies bedeutet, dass sie
zumindest einmal ausgeführt werden muss, denn erst nach dem ersten
Durchlauf wird der Ausdruck geprüft.

Die Schleife wird immer dann beendet, wenn der Ausdruck false
ergibt
86
do-while-Schleife
• Die do-while Schleife
do
anweisung;
while(ausdruck);
public class DoWhileSchleife
{
public static void main(String args[])
{
int i = 11;
do
Wird Schleife durchlaufen ??
{
System.out.println("i = " + i);
} while (i < 10);
}
}
86
for-Schleife
• Die for-Schleife:
for (init; test; update)
anweisung;
(Schleifen)-Kopf
• Der Kopf der for Schleife besteht aus drei Ausdrücken - jeder ist optional:
 Der init Ausdruck wird einmal vor dem Start der Schleife aufgerufen.
Dort werden Initialisierungen durchgeführt. Der init Teil darf aus
mehreren Ausdrücken bestehen, wenn die einzelnen Teilausdrücke durch
Kommata getrennt sind. Fehlt dieser Teil, so wird keine Initialisierung
durchgeführt.
 Der init Teil darf auch Variablendeklarationen enthalten
(Schleifenzähler)
 Der test Teil bildet den zu testenden Ausdruck. Analog zur while
Schleife wird dieser zu Beginn der Schleife ausgeführt. Ist der Ausdruck
true wird in die Schleife gegangen. Fehlt der Testausdruck wird vom
Compiler true eingesetzt.
87
for-Schleife 2
• Die for-Schleife
for (init; test; update)
anweisung;
• Der
update Ausdruck dient dazu, den Schleifenzähler zu verändern. Er
wird nach jedem Schleifendurchlauf ausgewertet. Fehlt dieser Ausdruck, so
wird nichts gemacht.
88
for-Schleife 3
public class ForSchleife
{
public static void main (String [] args)
{
for (int i = 0; i < 4; i++)
{
Was passiert hier ??
for (int j = 0; i < 4; j++)
{
System.out.println((i+1)+ " * "+ (j+1) +" = " + (i+1)*(j+1));
}
System.out.println();
}
}
Test-Ausdruck in 2. Schleife
}
führt zu Endlosschleife!!
Typischer copy-paste bug!!
Korrekt:
for (int j = 0; j < 4; j++)
88
for-Schleife + Array
„Befüllen“ eines 2 dimensionalen Arrays mit Zahlen:
public class Fill2DimArray
{
public static void main (String [] args)
{
int [][] multiTab = new int [4][4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
multiTab[i][j] = (i+1) * (j+1);
}
}
}
}
multiTab
i
j
0
0,1,2,3
1,2,3,4
1
2
3
0,1,2,3
0,1,2,3
0,1,2,3
2,4,6,8
3,6,9,12
4,8,12,16
i/j
0
1
2
3
0
1
2
3
4
1
2
4
6
8
2
3
6
9
12
3
4
8
12
16
88
Die erweiterte for-Schleife
•
Mit Java 5.0 (1.5) wurde die for-Schleife um eine syntaktische
Variante erweitert, die den Umgang mit listenartigen Strukturen
stark erleichtert.
• Diese Variante ist auch als foreach bekannt
for(formalparameter
anweisung;
: ausdruck)
• Der »formalparameter« ist dabei eine aus Datentyp und Variablenname
bestehende Parameterdeklaration (der Art java.lang.Object obj)
•
»ausdruck« ist eine Instanz oder ein Ausdruck des Typs
java.lang.Iterable oder ein Array.
90
Die erweiterte for-Schleife
•
Wendet man die erweiterte for-Schleife auf Arrays an, so ist
wie folgt vorzugehen:
int[] a = {1,2,3,4,5};
for(int element : a)
{ //”Für jedes Element aus a …
System.out.println (element);
}
äquivalent zu:
int[] a = {1,2,3,4,5};
for (int i = 0; i < a.length; i++)
{
System.out.println (a[i]);
}
91
Labels, Break & continue
• In Java gibt es zwei verschiedene Möglichkeiten, die normale Auswertungsreihenfolge in einer Schleife mit den Sprunganweisungen break und
continue zu verändern:
•

Taucht innerhalb der Schleife ein break auf, wird die Schleife verlassen,
und das Programm wird mit der ersten Anweisung nach der Schleife
fortgesetzt.

Taucht ein continue auf, so springt das Programm an das Ende des
Schleifenrumpfs und beginnt mit der nächsten Iteration.
Darüber hinaus gibt es in Java die Möglichkeit Schleifen mit Labels zu versehen.
Zusätzlich zu den Anweisungen break und continue gibt es daher in Java
noch break label; und continue label; - In diesem Fall wird zum definierten
Label gesprungen bzw. zur ersten Anweisung nach dem definierten Label.
89
Break & continue
Beispiel gelabeltes break:
public class LabeledBreak
{
public static void main(String args[])
{
int[][] a = new int [10][10];
loop1: for (int i=0; i<10; ++i)
{
for (int j=0; j<10; ++j)
{
if (a[i][j] > 42)
{
break;
}
if (a[i][j] == 0)
{
System.out.println("a ist 0. j = " + j + ", i = "+ i);
break loop1;
}
}
}
}
}
89
Break & continue
Beispiel gelabeltes loop:
public class LabeledLoop
{
public static void main(String args[])
{
int[][] a = new int [10][10];
loop1: for (int i=0; i<10; ++i)
{
for (int j=0; j<10; ++j)
{
if (a[i][j] > 42)
{
continue;
}
if (a[i][j] == 0)
{
System.out.println("a ist 0. j = " + j + ", i = "+ i);
continue loop1;
}
}
}
}
}
89
assert - Anweisung
Die assert Anweisung
assert ausdruck1
[
: ausdruck2
];
•
Diese Anweisung dient dazu, an einer bestimmten Stelle im Programm
einen logischen Ausdruck (ausdruck1) zu platzieren, von dem der
Programmierer annimmt, dass er stets wahr ist. In diesem Fall fährt das
Programm mit der nächsten Anweisung fort, andernfalls wird eine
Ausnahme des Typs AssertionException ausgelöst (bzw. der
optionale Ausdruck 2 als Fehlermeldung ausgegeben)
•
Ein solcher Ausdruck wird auch als Invariante bezeichnet, denn er bleibt
unverändert true, solange das Programm korrekt funktioniert.
•
Eine assert Anweisung erlaubt den Zustand eines Programmes zu
überprüfen und sicherzustellen, dass die prinzipielle Forderung für
einen korrekten Programmablauf eingehalten wird.
BEACHTE: Assertions sind in JAVA standardmässig deaktiviert.
Aktiviertung durch Parameter –ea zB: Java –ea HelloWorld
92
assert - Anweisung
•
Die assert Anweisung
assert ausdruck1
[
: ausdruck2
];
• Beispiel:
int[] a = {1,2,3,4,10};
for(int element : a)
{ //”Für jedes Element aus a …
assert (el<=5) : ”Zahl muss kleiner oder gleich 5 sein!!”;
System.out.println (element);
}
92
assert - Anweisung
• Ein assert kann natürlich auch mit einem if simuliert werden. Assert hat
jedoch folgende Vorteile
 Code ist kürzer
 es ist sofort zu erkennen, dass es sich um einen Korrektheitscheck und
nicht um ein logisches Programmkonstrukt handelt
 Assertions können zur Laufzeit wahlweise an als auch ausgeschaltet
werden
Herunterladen
Explore flashcards