13. Erweiterte Konzepte Grundlagen der - fbi.h

13. Erweiterte Konzepte
Grundlagen der
Programmierung 1 (Java)
Fachhochschule Darmstadt
Haardtring 100
D-64295 Darmstadt
Prof. Dr. Bernhard Humm
FH Darmstadt, 31. Januar 2006
Einordnung im Kontext der Vorlesung
1. Einführung
8. Parametrisierte Typen (Generics)
2. Einfache Programme
9. Fehler und Ausnahmen
3. Kontrollstrukturen
10. Gutes Programmieren
4. Objekt-Orientierung
11. Komponenten
5. Algorithmen und Datenstrukturen
12. Rekursion
6. Interfaces
13./14. Erweiterte Konzepte
7. Pakete
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 2
Agenda
Characters Advanced
Characters
Advanced
Strings Advanced
Arrays Advanced
Subversion
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 3
char Zeichencodes: ASCII und Unicode
ASCII (American Standard Code for Information Interchange)
• 1 Zeichen = 1 Byte (128 bzw. 256 Zeichen darstellbar)
• z.B. in Pascal oder C verwendet
Unicode (www.unicode.org)
• 1 Zeichen = 2 Bytes (65536 Zeichen darstellbar)
• auch Umlaute, griechische, arabische Zeichen etc.
• z.B. in Java und C# verwendet
• ASCII ist Teilmenge von Unicode
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 4
ASCII Code
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
space
!
"
#
$
%
&
'
(
)
*
+
,
.
/
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
´
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
DEL
Wichtige Steuerzeichen
BS backspace
löscht Zeichen vor Cursor
HT horizontal tab Tabulatorsprung
ESC escape
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
CR
LF
FF
Zeilenvorschub
carriage return
folgt auf CR
line feed
Seitenvorschub
form feed
31.1.2006, Seite 5
Unicode
0000 - 007F
0080 - 024F
0370 - 03FF
0400 - 04FF
0530 - 058F
0590 - 05FF
0600 - 06FF
...
ASCII-Zeichen
Umlaute, Akzente, Sonderzeichen
griechische Zeichen
cyrillische Zeichen
armenische Zeichen
Details siehe
hebräische Zeichen
http://www.unicode.org
arabische Zeichen
...
Deutsche Umlaute
00E4 ä
00F6 ö
00FC ü
00C4 Ä
00D6 Ö
00DCÜ
00DF ß
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 6
Unicode-Zeichenkonstanten
Alle Zeichen können auch mit ihrem Unicode-Wert angegeben werden:
'\udddd'
Beispiele:
'\u0041'
'\u000d'
'\u0009'
'\u03c0'
'A'
CR (carriage return)
TAB
p
Spezielle Zeichen
'\n'
'\r'
'\t'
'\\'
'\''
'\ddd'
LF (line feed, newline)
CR (carriage return)
TAB
\
'
Zeichenwert als Oktalzahl
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 7
Zeichen-Operationen
Zuweisungen
char ch1, ch2 = 'a';
ch1 = ch2;
// ok, gleicher Typ
int i = ch2;
// ok, char kann int zugewiesen werden
ch1 = (char)i; // Zuweisung nach Typumwandlung möglich
double ⊇ float ⊇ long ⊇ int ⊇ short ⊇ byte
⊇ char
Vergleiche (==, !=, <, <=, >, >=)
Zeichen sind nach Unicode-Wert geordnet;
Buchstaben und Ziffern liegen aufeinanderfolgend
if ('a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z') ...
Arithmetische Operationen (+, -, *, /, %)
10 + (ch - 'A')
// Ergebnistyp: int
Zeichenarrays
char[] s = new char[20];
char[] t = {'a', 'b', 'c'};
// initialisiert alle Elemente mit '\u0000'
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 8
Beispiel: Nachbauen von readInt
static int readInt() {
int val = 0;
char ch = In.read(); // liest ein einzelnes Zeichen
while (In.done() && '0' <= ch && ch <= '9') {
val = 10 * val + (ch - '0');
ch = In.read();
}
// ! In.done() || ch < '0' || ch > '9'
return val;
}
Schreibtischtest: Eingabe 123+
val
0
1
12
123
ch
'1'
'2'
'3'
'+'
(49)
(50)
(51)
(43)
'0' = 48
"Horner-Schema"
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 9
Standardfunktionen mit Zeichen
if (Character.isLetter(ch)) ...
if (Character.isDigit(ch)) ...
if (Character.isLetterOrDigit(ch)) ...
true, wenn ch ein Unicode-Buchstabe ist
true, wenn ch eine Ziffer ist
if (Character.isJavaIdentifierStart(ch)) ...
if (Character.isJavaIdentifierPart(ch)) ...
true, wenn ein Java-Name mit ch beginnen kann
true, wenn ch in einem Java-Namen vorkommen kann
if (Character.isLowerCase(ch)) ...
if (Character.isUpperCase(ch)) ...
true, wenn ch ein Kleinbuchstabe ist
true, wenn ch ein Großbuchstabe ist
ch1 = Character.toUpperCase(ch2);
ch1 = Character.toLowerCase(ch2);
wandelt ch2 in einen Großbuchstaben um
wandelt ch2 in einen Kleinbuchstaben um
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 10
Agenda
Characters Advanced
Strings Advanced
Strings
Advanced
Arrays Advanced
Subversion
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 11
Klassen zur String-Verarbeitung
– Zeichenketten (Strings) sind in Java Objekte
– Java stellt drei Klassen für den Umgang mit Strings zur Verfügung
– Klasse String
für konstante Zeichenketten, die nachträglich nicht mehr verändert werden
können
– Klasse StringBuffer
für variable Zeichenketten; es stehen Operationen zum Einfügen und Ändern
zur Verfügung
– Klasse StringTokenizer
um eine Zeichenkette in einzelne Teilzeichenketten (substrings) zu zerlegen;
hierzu können Trennzeichen spezifiziert werden, die die einzelnen Teilketten
voneinander trennen
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 12
Klasse String
– Zeichenketten sind Objekte auf die über Referenztypen
verwiesen wird
– eine konstante Zeichenkette ist eine unveränderbare Folge von
Zeichenkonstanten (Länge und Inhalt sind konstant)
– wichtige Unterschiede
String s3 = "";
// neues String-Objekt mit leerem String als
Wert
String s4 = " "; // String-Objekt erzeugt mit 1 Blank als
Wert
String s5 = null; // kein String-Objekt erzeugt
s3
""
s4
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
" "
s5
?
31.1.2006, Seite 13
Identität von Strings
String s5 = "Welt";
– eines neues String-Objekt erzeugt (mit dem Wert “Welt“)
– die Referenzvariable s5 verweist darauf
s5
“Welt“
s5 = "Europa";
– ein neues String-Objekt wird erzeugt
(mit dem Wert “Europa“)
s5
“Welt“
“Europa“
– Referenzvariable s5 verweist nun darauf
– Referenz auf das alte Objekt (“Welt“) geht verloren
String s6 = s5
– es wird neue Referenzvariable s6 erzeugt
– s6 verweist auf das selbe Objekt wie die s5
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
s5
s6
"Europa"
31.1.2006, Seite 14
String Methoden (1/2)
– Konkatenation (Aneinanderhängen) von Strings über speziellen Operator +
z.B.: System.out.println( "Hallo" + "Welt" );
– Vergleichen von Strings
– Vergleich 2 Referenzvariablen mit == vergleicht nur deren Referenzen
– Vergleich des Inhalts zweier String-Objekte mit Methode equals()
if (str1.equals(str2)) ... // str1 & str2 seien String-Objekte
– Inhalt (Werte) eines String-Objektes kann nie geändert werden
– jede Zuweisung erzeugt immer ein neues String-Objekt
String s = "Hallo";
s = s + " Welt";
s
s
– benötigt man String-Objekte, die verändert werden
sollen, benötigt man eine andere Klasse StringBuffer
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
"Hallo"
"Hallo"
"Hallo Welt"
31.1.2006, Seite 15
String Methoden (2/2)
Konstruktoren
// erzeugt neuen String als Kopie von s
String (String s)
statische Methoden
static String valueOf(int i)
// erzeugt String-Objekt aus int-Wert
static String valueOf(double d)
// erzeugt String-Objekt aus double-Wert
Instanz-Methoden
int length()
// liefert Länge des Strings
char charAt(int index)
// liefert Zeichen an Stelle index
int compareTo(String par)
// lexikographische Ordnung
// 0, falls beide Strings gleich sind, einen negativen Wert, falls this-String < par
// entfernt Blanks an Anfang und Ende
String trim()
String substring(int beg, int end);
// liefert Teilstring mit Indizes beg<= i < end
int indexOf(String par)
// sucht String par & liefert Index auf 1.Vorkommen
// -1, falls es den String nicht gibt
int indexOf(String par, int j)
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
// sucht String par ab Index j
31.1.2006, Seite 16
Beispiel: Entfernen doppelter Blanks
– Aufgabe: Programm soll zwei aufeinanderfolgende Blanks durch
ein einzelnes ersetzen!
Hallo__Welt
–
->
Hallo_Welt
Programm-Ausschnitt Spaces.java (ohne Eingabe)
String s = "dieser
String enthält viele Blanks";
int blankPos = 0, starteSucheVon = 0;
while (true) {
blankPos = s.indexOf(" ",starteSucheVon);
if (blankPos==-1)
// keine Blanks mehr enthalten
break;
else if (blankPos==0)
// Blank direkt am Anfang
s = s.substring(1,s.length()-1);
// 1. Zeichen entfernen
else s = s.substring(0,blankPos) // substring < blankPos
+ " "
// 1 Blank
+ s.substring(blankPos+2,s.length()-1);// restl.String
starteSucheVon = blankPos+2;
}
System.out.println(s);
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 17
Klasse StringBuffer - Variable Zeichenketten
– Klasse StringBuffer repräsentiert veränderbare Zeichenketten mit
folgenden Eigenschaften
– Länge der Zeichenkette ist nicht festgelegt
– Inhalt einer Instanz lässt sich verändern.
– Erzeugung von StringBuffer-Objekten mit new und Konstruktoren
– StringBuffer()
– StringBuffer(int length)
– StringBuffer(String str)
– Methoden zur Manipulation von Zeichenketten
– Anhängen an das Ende einen vorhanden String:
append(String s) oder append(StringBuffer sb)
– Einfügen in einen vorhanden String:
insert(int pos, String s)
– Konvertierung einer variablen in eine konstante Zeichenkette
String s = sb2.toString();
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 18
Beispiel StringBuffer
– Vorgehensweise zur Manipulation von String-Objekten
– Umwandlung des zu manipulierenden String-Objektes in
StringBuffer-Objekt
– Manipulation mit StringBuffer-Methoden
– Rückumwandlung mittels toString-Methode in StringObjekt
String str = "moin moin";
StringBuffer buffer = new StringBuffer(str);
for (int i=0; i < buffer.length(); i++)
If (buffer.charAt(i) == 'o')
buffer.setCharAt(i,'e');
str = buffer.toString();
System.out.println(str); // mein mein
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 19
Klasse StringTokenizer - Zerlegung von Zeichenketten
Klasse StringTokenizer ermöglicht es, eine Zeichenkette in einzelnen
Zeichenketten zu zerlegen
– Trennzeichen müssen spezifiziert werden, die Teilzeichenketten (Token)
trennen
– Konstruktoren
– StringTokenizer(String str)
erzeugt neues Objekt für str mit voreingestellten Trennzeichen
Leerzeichen, Tabulator etc.
– StringTokenizer(String str, String delimiters)
erzeugt neues Objekt für str. Als Trennzeichen dienen die in delimiters
enthaltenen Zeichen
– wichtigste Methoden
– public String nextToken()
liefert die nächste Teilzeichenkette
– public boolean hasMoreToken()
wahr wenn noch weitere Token vorliegen
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 20
Beispiele StringTokenizer
String text = "Name, Vorname";
StringTokenizer Teilkette = new StringTokenizer(text,",");
String name = Teilkette.nextToken();
String vorname = Teilkette.nextToken();
String name = "aber = hallo + hier";
StringTokenizer st = new StringTokenizer(name, "+=");
while ( st.hasMoreTokens() ) {
System.out.println( st.nextToken() );
}
Ausgabe: > aber
> hallo
> hier
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 21
Agenda
Characters Advanced
Strings Advanced
Arrays Advanced
Arrays
Advanced
Subversion
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 22
Mehrdimensionale Arrays (1/2)
a[0][0]
a[0][2]
Zweidimensionales Array ≡ Matrix
a[0]
a[1]
a[2]
a[3]
In Java als Array von Arrays implementiert
a
a[0][0]
a[0][1]
a[0][2]
Deklaration und Erzeugung
a[0]
a[1][0]
a[1][1]
a[1][2]
a[2][0]
a[2][1]
a[2][2]
a[3][0]
a[3][1]
a[3][2]
a[1]
a[2]
int[][] a;
a = new int[4][3];
Zugriff
a[i][j] = a[i][j]+1;
a[3]
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 23
Mehrdimensionale Arrays (2/2)
Zeilen können unterschiedlich lang sein (das ist aber selten sinnvoll)
a
a[0][0]
a[0][1]
a[0][2]
a[0][3]
a[0]
a[1][0]
a[1][1]
a[2][0]
a[2][1]
a[1]
a[2][2]
int[][] a = new int[3][];
a[0] = new int[4];
a[1] = new int[2];
a[2] = new int[3];
a[2]
Initialisierung
int[][] a = {{1, 2, 3},{4, 5, 6}};
a
1
2
3
4
5
6
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 24
Beispiel: Matrixmultiplikation
b
a
i
×
k
c
=
i
j
j
c0,0 = a0,0*b0,0 + a0,1*b1,0 + a0,2*b2,0
static float[][] matrixMult (float[][] a, float[][] b) {
float[][] c = new float[a.length][b[0].length];
for (int i = 0; i < a.length; i++)
for (int j = 0; j < b[0].length; j++) {
float sum = 0;
for (int k = 0; k < b.length; k++)
sum += a[i][k] * b[k][j];
c[i][j] = sum;
}
return c;
}
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
⇒
⇒
⇒
⇒
31.1.2006, Seite 25
Agenda
Characters Advanced
Strings Advanced
Arrays Advanced
Subversion
Subversion
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 26
Subversion: ein exzellentes Open Source
Konfigurationsmanagement-System
http://subversion.tigris.org/)
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 27
Subclipse: Das Plugin von Subversion in Eclipse
2
3
1
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 28
SVN Repository Explorer
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 29
Team Synchronizing
Bernhard Humm: „Grundlagen der Programmierung I (Java)“. FH Darmstadt, WS 2005/2006
31.1.2006, Seite 30