Grundlagen der Informatik

Grundlagen der Informatik
Einführung in die objektorientierte Software-Entwicklung mit Java
Teil 1
Prof. Dr. Katrin Brabender
Labor für
Angewandte Informatik und Datenbanken
Version: 28.07.2006
Grundlagen der Informatik
WS 2006/2007
Seite 1
Themen des 1. Semesters
1. Grundbegriffe aus der Informatik
2. Zahlendarstellung und mathematische Grundoperationen in einem
Rechnersystem
3. Grundlagen der Booleschen Algebra
4. Softwareentwicklung mit Java
•
Datentypen
•
Kontrollstrukturen
•
Methoden
•
Grundlagen der Objektorientierung (Klassen, Vererbung, Kapselung etc.)
•
Ausnahmebehandlung
•
Die Klassen Object, String, StringBuffer
Grundlagen der Informatik
WS 2006/2007
Seite 2
1. Grundbegriffe aus der Informatik
Aufbau eines Rechnersystems
Grundlagen der Informatik
WS 2006/2007
Seite 3
Der Universalrechenautomat nach von Neumann
Der logische Aufbau moderner Computer folgt dem Konzept des
Mathematikers John von Neumann (1903-1957) und wurde in den Jahren
1946/47 in den USA entwickelt.
Der von Neumann Rechner besteht im Wesentlichen aus den drei Einheiten
-
Speicherwerk (Arbeitsspeicher)
Hier werden die Programme und Daten gespeichert
-
Rechenwerk
Hier werden die Rechenoperationen und logischen Verknüpfungen
ausgeführt
-
Steuerwerk
Hier werden der Programmablauf sowie die Ein- und Ausgabe von
Programmen und Daten gesteuert
Grundlagen der Informatik
WS 2006/2007
Seite 4
Grundlegende Eigenschaften des von Neumann Rechners
•
Struktur ist unabhängig von den zu bearbeitenden Problemen
•
Programme, Befehle und Daten befinden sich im selben Speicherwerk
•
Sein Speicher wird in einzelne Speicherplätze unterteilt, die eine
eindeutige Adresse haben.
=> Informationen können eindeutig angesprochen werden
•
Es wird das Duale Zahlensystem verwendet
•
Sequentielles Abarbeiten von Befehlen
Grundlagen der Informatik
WS 2006/2007
Seite 5
Die Zentraleinheit eines Computers
Steuerwerk
Hauptspeicher
CPU
Rechenwerk
Zentraleinheit
Komponenten der Zentraleinheit sind
-
Steuerwerk (control unit)
-
Rechenwerk
-
Hauptspeicher
CPU (Central Processing Unit)
Der Informationsaustausch erfolgt über zwei Bussysteme.
Grundlagen der Informatik
WS 2006/2007
Seite 6
Die CPU (Central Processing Unit)
Der Prozessor ist das Kernstück eines Computers.
Die CPU dient zur Verarbeitung von Daten, die sich im Speicher des
Rechners befinden.
Die CPU besteht aus dem Steuerwerk und Rechenwerk.
Grundlagen der Informatik
WS 2006/2007
Seite 7
Das Steuerwerk mit Befehlsregister, Befehlszähler, Adressregister
•
steuert den Austausch von Daten mit dem Arbeitsspeicher
•
steuert den Datenaustausch mit den Peripheriegeräten, wie Festplatte,
Drucker etc.
•
steuert die Ausführung der Maschinenbefehle
Register sind extrem schnelle Hilfsspeicherzellen mit denen die CPU die
logischen Operationen ausführen kann. Diese liegen nicht im Arbeitsspeicher
sondern direkt innerhalb der CPU und können deshalb vom Rechenwerk direkt
erreicht werden.
Grundlagen der Informatik
WS 2006/2007
Seite 8
Die wesentlichen Aufgaben des Steuerwerks sind
1. Befehlsdecodierung:
Erkennen eines Programmbefehls und Einleiten der zu seiner Ausführung
notwendigen Funktionen.
2. Ablaufsteuerung:
Steuern der Reihenfolge der auszuführenden Programmbefehle.
Der durchzuführende Befehl steht im Befehlsregister.
Die Adressen der benötigten Daten stehen im Adressregister.
Die Adresse des nächsten Befehls steht im Register Befehlszähler.
Grundlagen der Informatik
WS 2006/2007
Seite 9
Typische Befehle sind
LOAD Laden eines CPU Registers mit einem Wert aus dem
Speicher
STORE Speichern eines Registerinhaltes in einem Speicherplatz
des Speichers
ADD, SUB, MUL, DIV Arithmetische Operationen auf Registern
NOT, OR, AND, XOR Logische Befehle auf Registern
COMPARE Vergleich des Inhalts zweier Register
IN, OUT Ein- und Ausgabe von Daten an Register der Periperiegeräte
Grundlagen der Informatik
WS 2006/2007
Seite 10
Jeder dieser Befehle besitzt einen OpCode (Befehlsnummer).
Ein Programm besteht aus einer Folge von OpCodes.
Wird ein Programm ausgeführt, so wird die Programmdatei in den
Speicher geladen.
Die CPU übernimmt die Kontrolle und führt die den Opcodes
entsprechenden Befehle aus.
Ein internes Register, der Befehlszähler, zeigt immer auf den nächsten
auszuführenden Opcode.
Die CPU durchläuft dabei immer wieder den folgenden Zyklus
LOAD (Lade den Opcode, auf den der Befehlszähler zeigt)
INCREMENT (Erhöhe den Befehlszähler)
EXECUTE (Führe den Befehl, der zu dem Opcode gehört, aus)
Grundlagen der Informatik
WS 2006/2007
Seite 11
3. Koordination
Koordination sämtlicher Transporte auf den verschiedenen Bussystemen.
Grundlagen der Informatik
WS 2006/2007
Seite 12
Das Rechenwerk
Besteht im Wesentlichen aus der ALU (Arithmetical Logical Unit).
Hier werden alle arithmetischen und logischen Operationen ausgeführt,
indem zwei Datenregister miteinander logisch verknüpft werden.
Von der Breite des Datenregisters leitet man die Bezeichnung des
Prozessors ab, z.B. ein 16 Bit Prozessor hat Datenregisterbreite von 16 Bit.
Beispiele:
8 Bit Prozessor: Intel 8086 (XT), 8051
16 Bit Prozessor: Intel 80286 (AT)
32 Bit Prozessor: Intel 80386, Motorola 68000
64 Bit Prozessor: Intel Itanium, AMD Athlon 64
Grundlagen der Informatik
WS 2006/2007
Seite 13
Der Hauptspeicher
ist ein außerhalb der CPU befindlicher Speicher für Daten und Programme.
Wird als RAM (Random Access Memory) bezeichnet.
Die Bits des Hauptspeichers sind byte- oder wortweise organisiert.
Jeder Befehl kann in Abhängigkeit von der Struktur des Prozessors auf ein
oder mehrere Byte zugreifen, um sie zu lesen, zu bearbeiten oder zu
schreiben.
Jedes Byte des Speichers erhält eine Adresse.
Auf jedes Byte kann direkt zugegriffen werden.
Grundlagen der Informatik
WS 2006/2007
Seite 14
Ein weiterer dynamischer Speicher ist der
Cache
Zusätzlicher Speicher zwischen dem Hautspeicher und den
Registern der Zentraleinheit, auf den besonders schnell zugegriffen
werden kann.
Im Normalfall bildet der Cache zusammen mit dem Prozessor ein
Bauteil.
Kleinere Programmstrukturen, die sich komplett im Cache befinden,
können so aus diesem deutlich schneller abgearbeitet werden.
Grundlagen der Informatik
WS 2006/2007
Seite 15
Das BUS System
Unterschieden wird zwischen internem und externem Bussystem.
Das interne Bussystem sorgt für den Datenaustausch innerhalb der
CPU, d.h. zwischen Rechenwerk und Steuerwerk.
Das externe Bussystem (Systembus) sorgt für den Datenaustausch
zwischen CPU und Hauptspeicher sowie CPU und Peripheriegeräte.
Grundlagen der Informatik
WS 2006/2007
Seite 16
Das externe Bussystem bzw. der Systembus besteht aus
Adressbus, Datenbus und Steuerbus.
•
Adressbus selektiert die Komponenten
•
Datenbus übermittelt die Daten
•
Steuerbus übernimmt Verwaltungsfunktion z.B. Umschalten von Lesen auf
Schreiben
Adressen / Adressbus
Steuerwerk
Befehle / Datenbus
Rechenwerk
Hauptspeicher
Daten / Datenbus
Grundlagen der Informatik
WS 2006/2007
Seite 17
Die Bestandteile eines Rechnersystems
• Eingabeeinheit
• Verarbeitungseinheit
• Ausgabeeinheit
Grundlagen der Informatik
WS 2006/2007
Seite 18
Peripherie
Die Gesamtheit der Eingabegeräte, Speichergeräte, Dialoggeräte und
Ausgabegeräte , d.h. alle Geräte außerhalb der Zentraleinheit bezeichnet
man als Peripherie
Grundlagen der Informatik
WS 2006/2007
Seite 19
Massenspeicher / Festplatte
Speichern von großen Datenmengen
Köpfe, Zylinder, Sektoren, Spuren
Spur
Sektor
Spur 1023
Spur 0
Zylinder
Kopf
Grundlagen der Informatik
WS 2006/2007
Seite 20
Organisation von Massenspeicher
Die Verwaltung der physikalischen Eigenschaften einer Platte wird durch
BIOS und Betriebssystem vollständig gekapselt.
Für den Benutzer erfolgt die Organisation von Festplatten in Verzeichnissen.
Die Organisation von Dateien erfolgt in Abhängigkeit vom Betriebssystem in
• Laufwerke (DOS/Windows)
• Verzeichnisse
• Unterverzeichnisse
Zum Einrichten von Verzeichnisstrukturen muß berücksichtigt werden
• Benutzerrechte, Zugriffsrechte
• Sicherungskonzepte
• Backup-Strategien
Grundlagen der Informatik
WS 2006/2007
Seite 21
Grundlagen der Informatik
WS 2006/2007
Seite 22
Dateneingabe-Geräte
•
•
•
•
Tastatur
Maus
Touchpad
Scanner etc.
Dateiausgabe-Geräte
•
•
Bildschirm
Drucker etc.
Schnittstellen
•
•
Netzwerk
Seriell, Parallel, USB
Grundlagen der Informatik
WS 2006/2007
Seite 23
Software in einem Rechnersystem
Unter Software versteht man alle Programme, Prozeduren und Objekte, die
ein Rechnersystem lauffähig machen.
Unterschieden wird zwischen Systemsoftware und Anwendungssoftware.
Zur Systemsoftware zählen alle Programme, die für den korrekten Ablauf
von Rechnern verantwortlich sind, wie BIOS und Betriebssystem.
Grundlagen der Informatik
WS 2006/2007
Seite 24
BIOS
Das BIOS – Basic IO System - enthält
•
grundlegende Hilfsprogramme zur Ansteuerung von
Hardwarekomponenten (z.B. Tastatur, Maus, Festplatte)
•
Programme, die nach Einschalten des Rechners ausgeführt werden, wie
• Prüfung, welche Geräte angeschlossen sind,
• Funktionstest des Speichers
• Laden des Betriebssystems
•
Ist das BIOS in einem nicht flüchtigem Speicher (ROM oder EPROM) fest
im Gerät eingebaut, so spricht man auch von Firmware.
Grundlagen der Informatik
WS 2006/2007
Seite 25
Das Betriebssystem
Verwaltet die Ressourcen des Rechners und stellt Dienstleistungen zur
Verfügung.
Die zentralen Aufgaben des Betriebssystems sind
•
Ablaufsteuerung
Laden, Starten und Abarbeiten der Anwenderprogramme
•
Speicherverwaltung
z.B. Festlegung der vom Programm zu benutzenden Adressbereiche des
Hauptspeichers
•
Konfigurationsverwaltung
Erkennen aller angeschlossenen Peripheriegeräte
Grundlagen der Informatik
WS 2006/2007
Seite 26
•
Ein- und Ausgabesteuerung
•
Prozessverwaltung
•
Zugriff und Verwaltung des Dateisystems
Grundlagen der Informatik
WS 2006/2007
Seite 27
Die Anwendungssoftware
Anwendungsprogramme unterstützen den Anwendern bei der
Lösung von Problemen.
Bsp: Textverarbeitungsprogramme, Tabellenkalulation etc.
Grundlagen der Informatik
WS 2006/2007
Seite 28
Zusammenfassung
Ein Computersystem besteht aus den Komponenten
Grundlagen der Informatik
WS 2006/2007
Seite 29
2. Zahlendarstellung und mathematische Grundoperationen in
einem Rechnersystem
•
Zahlensysteme
•
Zahlenkonvertierung
•
Grundoperationen in den Zahlensystemen - Das Rechnen im Dualsystem
•
Subtraktion und Division mit Hilfe des Komplements
•
Darstellung von Ganzen- und Gleitkommazahlen im Rechner
Grundlagen der Informatik
WS 2006/2007
Seite 30
Zahlensysteme
Der Wert einer Zahl im Dezimalsystem kann dargestellt werden in der Form
n
x = ± ∑ bi * 10 i , b i ∈ {0 ,1, 2,3, 4,5, 6,7 ,8,9}
i=m
Bsp:
345,23 = 3*102 + 4*101 + 5*100 + 2*10-1 + 3*10-2
Diese Darstellung nennt man Stellenwertsystem.
Grundlagen der Informatik
WS 2006/2007
Seite 31
Definition Stellenwertsystem
System zur Darstellung von Zahlen durch Ziffern, bei denen der Wert
einer Ziffer von der Stelle abhängt, an der sie innerhalb der Zahl
geschrieben ist.
Für den Wert einer Zahl z in einem Stellenwertsystem zur Basis B gilt
n
z = ±∑ bi ∗ Bi , bi ∈ {0,1,2,K, B − 1}
mit
B∈IN, B ≥ 2
i =m
Grundlagen der Informatik
WS 2006/2007
Seite 32
Beispiel für einige Stellenwertsysteme
Zahlensystem
Dualsystem
Fünfersystem
Siebenersystem
Oktalsystem
Dezimalsystem
Hexadezimalsystem
Zahlenbasis
B=2
B=5
B=7
B=8
B=10
B=16
Ziffern
0,1
0,1,2,3,4
0,1,2,3,4,5,6
0,1,2,3,4,5,6,7
0,1,2,3,4,5,6,7,8,9
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
Beispiel
11000011
1240
366
303
195
C3
Grundlagen der Informatik
WS 2006/2007
Seite 33
Das Dualsystem ist ein Spezialfall des Binärsystems.
Binärsystem
Eine Menge, die nur aus zwei Zeichen besteht, z.B. Morsealpabet,
Fußgängerampel etc.
Für die interne Verarbeitung innerhalb eines Rechners wird das Dualsystem
benutzt.
Aber auch das Oktal- und Hexadezimalsystem sind wichtige
Stellenwertsysteme, da sie als abkürzende Schreibweise für Dualzahlen
benutzt werden können.
Da 8=23 und 16=24, können jeweils 3 Dualziffern durch eine Oktalziffer und 4
Dualziffern durch eine Hexadezimalziffer ersetzt werden.
Grundlagen der Informatik
WS 2006/2007
Seite 34
Besteht die Gefahr der Verwechslung, wird das benutzte Stellenwertsystem
durch Zusätze markiert:
Dualsystem:
100100112
Oktalsystem:
2238
Dezimalsystem:
14710
Hexadezimalsystem:
9316
Grundlagen der Informatik
WS 2006/2007
Seite 35
Vergleichstabelle
Dezimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Dual
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
Oktal
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
Hexadezimal
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Grundlagen der Informatik
WS 2006/2007
Seite 36
Zahlenkonvertierung
Dezimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Die Umwandlung von Dual in Oktal oder
Dual in Hexadezimal und umgekehrt ist
sehr einfach.
Umwandlungstabellen
Dezimal
0
1
2
3
4
5
6
7
Dual
000
001
010
011
100
101
110
111
Oktal
0
1
2
3
4
5
6
7
Dual
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Hexa
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Grundlagen der Informatik
WS 2006/2007
Seite 37
Beispiel:
1 0 0 1 0 1 1 1 0 1, 1 0 1 0 0 1 12=X16
0 0 1 0 0 1 0 1 1 1 0 1, 1 0 1 0 0 1 1 0
2
5
D
A
6
Hinweis:
Die Umwandlung von Dezimalzahlen in Dual-, Oktal- oder
Hexadezimalzahlen ist auf diese einfache Art nicht möglich. Hierfür gibt es
Konvertierungsverfahren.
Grundlagen der Informatik
WS 2006/2007
Seite 38
Umwandlung von ganzen Zahl im Dezimalsystem in eine Zahl beliebiger Basis:
Das Quellenverfahren
Beispiel:
232010=X8
a)
Z div 8 Z mod 8
Z
2320
?
?
b)
c)
d)
Z
2320
290
36
Ergebnis:
Z div 8
290
36
?
Z mod 8
0
2
?
Z
2320
290
Z div 8
290
?
Z mod 8
0
?
Z
2320
290
36
4
Z div 8
290
36
4
0
Z mod 8
0
2
4
4
232010= 44208
Grundlagen der Informatik
WS 2006/2007
Seite 39
Umwandlung einer ganzen Zahl beliebiger Basis in eine Dezimalzahl:
Das Zielverfahren
Verfahren:
Multipliziere die erste Ziffer (von links) der umzuwandelnden Zahl
mit ihrer Basis B, addiere dazu die nächste Ziffer, multipliziere das
Ergebnis erneut mit Basis B, usw.
Beispiel
44208=X10
4
B=8
4
32
36
2
288
290
0
2320
2320
Grundlagen der Informatik
WS 2006/2007
Seite 40
Grundoperationen in den Zahlensystemen - Das Rechnen im
Dualsystem
Unsere üblichen Rechenverfahren sind allgemein für Stellenwertsysteme
gültig. Es wird sich zeigen, dass sich alle 4 Grundrechenarten im
Dualsystem auf die Addition zurückführen lassen.
3.1 Addition im Dualsystem
+
0
1
Additionsregeln 0
0
1
1
1 10
Beispiel für eine Addition
1 0 0 1 1 12 + 1 1 0 1 12 = ?
+
Übertrag
1 0
1
1 1
1 0 0
0
1
1
0
1
0
1
0
1 1
1 1
1
1 0
Grundlagen der Informatik
WS 2006/2007
Seite 41
Multiplikation im Dualsystem
Multiplikationsregeln
*
0
1
0
0
0
1
0
1
Verfahren:
a.) Verschiebe die zu multiplizierende Zahl nach links
b.) Addiere die Zahlen
Grundlagen der Informatik
WS 2006/2007
Seite 42
Beispiel für eine Multiplikation
1
Übertrag
0 0 1 1 0 *
0
1 0
1 0 0
0 0 0 0
1 0 0 1 1
1 1 1 1
1 1 0 1 0
1
0
0
1
0
0
1
0
0
0
1
1
0
1 1 0
0 0 0
1 0
0
0 1 0 0
Grundlagen der Informatik
WS 2006/2007
Seite 43
Subtraktion im Dualsystem
Subtraktionsregeln
0
-0
0
Leihen 0
0
-1
1
1
1
-0
1
0
1
-1
0
0
Beispiel
1
Leihen
Übertrag 1
0
1
1
1
0
1
0
0
1
1
0
Dieses Rechenverfahren ist für einen Computer nicht geeignet.
Grundlagen der Informatik
WS 2006/2007
Seite 44
Division im Dualsystem
Das schriftliche Divisionsverfahren kann analog zum Dezimalsystem benutzt
werden.
Divisionsregeln
0 : 0 = verboten
0:1=0
1 : 0 = verboten
1:1=1
Dieses Rechenverfahren ist für eine elektronische Rechenanlage nicht
geeignet.
Grundlagen der Informatik
WS 2006/2007
Seite 45
Beispiel
11011101
- 10011
010001
- 000000
100010
10011
0011111
10011
011000
10011
001010
:
10011
=
1 0 1 1, 1 0 1....
Grundlagen der Informatik
WS 2006/2007
Seite 46
Subtraktion und Division mit Hilfe des Komplements
Definition 2-Komplement einer Dualzahl
Das 2-Komplement einer Dualzahl ist die Ergänzung zur nächst höheren
Bit-Wertigkeit (=Zweierpotenz).
Bildungsrezept
Das 2-Komplement einer Dualzahl bildet man durch Invertieren (Ersetzen
von 0 durch 1 und umgekehrt) der Zahl und anschließender Addition
einer 1.
Beispiel: 2-Komplement zur Zahl 101012 (= 2110)
01010
+
1
0 1 0 1 1 (= 1110)
Grundlagen der Informatik
WS 2006/2007
Seite 47
Subtraktion durch Addition des Komplements
1. Schritt: Subtrahend durch Voranstellen von Nullen auf die gleiche
Stellenanzahl des Minuenden bringen
2. Schritt: Bilde das 2-Komplement des erweiterten Subtrahenden
3. Schritt: Addiere Minuend und das 2-Komplement des Subtrahenden.
Der Übertrag über die höchste vorgegebene Stellenanzahl wird nicht
berücksichtigt.
Beispiel: 1 0 1 0 1 12 - 1 0 0 0 1 2 (= 4310 - 1710) = 2610
Schritte 1 + 2
Schritt 3
010001
101110
+
1
101111
101011
+ 101111
1 011010
Grundlagen der Informatik
WS 2006/2007
Seite 48
Division durch fortlaufende Addition des Komplements
Verfahren
1. Schritt: Divisor durch Voranstellen von Nullen auf die gleiche
Stellenanzahl des Dividenden bringen.
2. Schritt: Bilde 2-Komplement des erweiterten Divisors
3. Schritt: Addiere 2-Komplement zum Dividenden. Überträge über die
höchste Stellenzahl werden notiert, aber für die weitere Rechnung
zunächst nicht verwendet.
4. Schritt: Wiederhole Schritt 3 bis kein Übertrag mehr auftritt.
Das Ergebnis der letzten Addition, bei der es noch zu einem Übertrag
kam, ist der Divisionsrest. Die Übertragseinsen werden addiert und
bilden das Ergebnis der Division.
Grundlagen der Informatik
WS 2006/2007
Seite 49
Beispiel: 1 0 1 0 0 12 : 1 1 12 ( = 4110 : 710)
Schritte 1 + 2
Schritt 3
+
1
000111
111000
+
1
111001
+
1
+
1
+
1
+
1
+
101001
111001
100010
111001
011011
111001
010100
111001
001101
111001
000110
111001
111111
Ergebnis: 1 0 1 0 0 02 : 1 1 12 = 1 + 1 + 1 + 1 + 1 Rest 110 = 1 0 1 Rest 110
Grundlagen der Informatik
WS 2006/2007
Seite 50
Informationsdarstellung / Codierung
Computer können intern nur Bits verarbeiten.
Daher muss jedes Zeichen in eine Bitfolge umgewandelt werden.
Unter einem Zeichen versteht man Buchstaben, Ziffern (z.B. „0“, „1“),
Sonderzeichen (z.B. „$“, „€“,…) und Steuerzeichen (z.B. „\n“ für Zeilenumbruch)
Das Ersetzen eines Zeichens in eine Bitfolge nennt man Codierung.
Die Umwandlungsvorschrift ist ein Code.
Es wurden eine Reihe von Computercodes entwickelt.
Beispiele hierfür sind der ASCII-Code sowie der Unicode.
Grundlagen der Informatik
WS 2006/2007
Seite 51
ASCII-Code
American Standard Code for Information Interchange
7- Bit Code, d.h. 27=128 Zeichen sind darstellbar, davon
•
32 Steuerzeichen
(ASCII 0 bis ASCII 31 entspricht Tastenkombination Ctrl-A bis Ctrl-Z, z.B.
Ctrl-H Backspace, Ctrl-M Return),
•
84 internationale Schriftzeichen (lateinisches Alphabet, Ziffern,
Sonderzeichen),
•
12 nationale Schriftzeichen.
Grundlagen der Informatik
WS 2006/2007
Seite 52
Addition der Zeile und Spalte ergibt den ASCII-Wert des entsprechenden
Zeichens, z.B. ASCII 52 = 4.
Bei der ASCII-Codierung werden nur 7 Bits eines Bytes benutzt,
das achte Bit dient als Kontrollbit für die Datenübertragung.
Grundlagen der Informatik
WS 2006/2007
Seite 53
ASCII-Erweiterung
Erweiterung des ASCII-Satzes auf 8-Bit Code,
d.h. 28 = 256 Zeichen sind darstellbar.
Somit ergibt sich ein weiterer verfügbarer Bereich von
ASCII 128 bis ASCII 255.
IBM-PCs sowie dazu kompatible Rechner benutzen diesen zusätzlichen
Code zur Darstellung von sprachspezifischen Zeichen,
wie z.B. „ä“ (ASCII 132), „ö“ (ASCII 148).
Bemerkung:
Es kann zu Problemen beim Datenaustausch zwischen Rechnern mit
unterschiedlicher ASCII-Erweiterung kommen.
Grundlagen der Informatik
WS 2006/2007
Seite 54
Unicode
•
16-Bit Code, d.h. er umfasst 216 = 65536 Zeichen
•
umfasst Schriftzeichen aller Verkehrssprachen der Welt
Grundlagen der Informatik
WS 2006/2007
Seite 55
Zahlendarstellung im Rechner
Darstellung ganzer Zahlen (Datentyp INTEGER)
•
Können direkt in Dualzahlen umgewandelt werden
•
Werden in ihrer Bitdarstellung gespeichert und verarbeitet
Die meisten Programmiersprachen unterscheiden zwischen
Short Integer: Speicherlänge 2 Byte (=16 Bits)
Long Integer: Speicherlänge 4 Byte (= 32 Bits)
Grundlagen der Informatik
WS 2006/2007
Seite 56
Mit 2 Bytes können 216 verschiedene Zahlen dargestellt werden,
mit 4 Bytes 232 verschiedene Zahlen.
Daher lassen sich folgende Bereiche von Integer Zahlen darstellen:
Short Integer Zahlen von –215 bis 215-1
Long Integer Zahlen von
–231
bis
231-1
(-32768 bis 32767)
(-2147483648 bis 2147483647)
Die positiven ganzen Zahlen werden direkt in ihrer Bitdarstellung gespeichert
(bei Short Integer von 0000 0000 0000 0000 bis 0111 1111 1111 1111).
Das vorderste Bit ist hier immer 0.
Grundlagen der Informatik
WS 2006/2007
Seite 57
Die negativen ganzen Zahlen werden abgespeichert als 2-Komplement
ihres Betrages.
Beispiel
Für Short integer hat –1 die Darstellung 1111 1111 1111 1111
Der Zahlenbereich bei Short Integer erstreckt sich also von
1111 1111 1111 1111 bis 1000 0000 0000 0000
Grundlagen der Informatik
WS 2006/2007
Seite 58
Standardformate für die Darstellung ganzer Zahlen
Bereich
-128..127
-32768..32767
-231..231-1
-263..263-1
Format
8 Bit
16 Bit
32 Bit
64 Bit
Java
byte
short
int
long
Grundlagen der Informatik
WS 2006/2007
Seite 59
Darstellung von Kommazahlen (Datentyp REAL)
Alle Zahlen Z dieses Typs werden im Rechner in der Gleitpunktdarstellung
(Gleitkommadarstellung) dargestellt:
Z = V * M * BE
mit V: Vorzeichen, E: Exponent, M: Mantisse, B: Basis
Beispiel
75 = 75*100 = 7,5*101 = 0,75*102 = ...
- 0,36 = - 0,36* 100 = - 3,6*10-1= - 36*10-2=...
Grundlagen der Informatik
WS 2006/2007
Seite 60
Eigenschaften der Gleitpunktdarstellung
•
Die Gleitpunktdarstellung ist eine Methode zur näherungsweisen
Darstellung von reellen Zahlen.
•
Sie ist eine Darstellung, die bei festem Bitformat
- ein möglichst großes Intervall der reellen Zahlen umfasst und
- deren Genauigkeit bei kleinen Zahlen sehr hoch, bei großen Zahlen
niedrig ist.
•
In einer Rechenanlage werden Mantisse und Exponent im Dualsystem
dargestellt.
•
REAL-Zahlen werden im Rechner meist in 32 (short real, float)
oder 64 Bits (long real, double) abgespeichert:
Grundlagen der Informatik
WS 2006/2007
Seite 61
Damit Gleitkommazahlen in einer Rechenanlage eine eindeutige
Darstellung haben, werden sie normiert dargestellt.
Eine zur Basis 2 normierte Gleitkommazahl ist eine Zahl, bei der der
Exponent so gewählt wird, dass die Zahl in der Form
±1, m1m2m3….mn*2E
dargestellt werden kann.
Beispiel: 10,01 = 1,001 * 21
Bemerkung:
Bei der Verwendung normierter Gleitkommazahlen muss die 1 vor dem
Komma nicht gespeichert werden, da sie immer vorhanden ist.
Grundlagen der Informatik
WS 2006/2007
Seite 62
IEEE-Norm (Institute of Electrical and Electronics Engineers)
Mitte der Achtzigerjahre wurde vom Institute of Electrical and Electronics
Engineers die sog. IEEE-Norm verabschiedet, die mittlerweile Standard in den
meisten Rechnern ist.
Für Exponent und Mantisse sind hierbei eine feste Bitanzahl vorgegeben.
Exponent
v
Mantisse
e
m
short real (32 Bits): Vorzeichen: 1Bit, Exponent: 8 Bit, Mantisse:23 Bit
long real (64 Bits): Vorzeichen: 1Bit, Exponent: 11 Bit, Mantisse:52 Bit
Grundlagen der Informatik
WS 2006/2007
Seite 63
Das Vorzeichenbit
Das erste Bit (engl.. most significant bit) wird als Vorzeichenbit interpretiert.
0 = positiv, 1 = negativ
Die Exponentenbits (für short real)
Die nächsten acht Bits codieren den Exponenten e.
Mit 8 Bits können maximal 28 = 256 verschiedene Exponenten codiert werden.
Damit können Zahlen im Bereich von –127 bis 128 dargestellt werden.
Damit das Vorzeichen des Exponenten nicht gespeichert werden muss, wird zum
Exponenten + 127 addiert, so dass der Exponent aus Zahlen von 1 bis 254
besteht.
0 und 255 sind für betragsmäßig sehr kleine Werte sowie „Unendlich“ reserviert.
Grundlagen der Informatik
WS 2006/2007
Seite 64
Die Mantissenbits (für short real)
Die restlichen 23 Bits dienen zur Codierung der Mantisse.
Die Mantisse wird normiert dargestellt, wobei die 1 vor dem Komma nicht
mitgespeichert wird.
Damit entspricht eine short real Codierung der Zahl
für e ∈ ] 0;255 [
Z = (-1)v * 1,m * 2e-127
Bemerkung: Die 64 Bit Codierung von long real erfolgt analog. Es gilt
Z = (-1)v * 1,m * 2e-1023
für e ∈ ] 0;2047 [
Grundlagen der Informatik
WS 2006/2007
Seite 65
Sonderfälle
e
m
Gleitkommazahl Z
0
≠0
0
0
-1v * 0
255
0
-1v * ∞
255
≠0
-1v*0,m * 21-127
NaN
NaN = Not a Number, d.h. nicht definiert
Grundlagen der Informatik
WS 2006/2007
Seite 66
Beispiel: 4,75 als IEEE Zahl (short real)
4,75 = 100,11
29 28 27 26 25 24 23 22
21 20 2-1 2-2 2-3 2-4 2-5 2-6
,
1
Normieren ergibt:
1,0011*22
1
,
0
0
1
1
1
1
0
Exponent mit 127 addieren: 127+2 = 129 = 10000001
Damit ergibt sich
IEEE Zahl: 0 10000001 00110000000000000000000
Beachte: Bei der Mantisse wird die 1 vor dem Komma nicht mitgespeichert.
Grundlagen der Informatik
WS 2006/2007
Seite 67
Beispiel: gegeben sei IEEE Zahl (short real)
1 10000101 10110000000000000000000
gesucht: zugehörige Dezimalzahl
Exponent = 10000101 = 13310 => Exponent - 127 = 6
Also entspricht die IEEE Zahl der Dezimalzahl
- (1* 20 + 1* 2-1 + 0*2-2+1*2-3+1*2-4)*26= -108
Grundlagen der Informatik
WS 2006/2007
Seite 68
3. Grundlagen der Boolesche Algebra
•
Definition
•
Grundlagen der Schaltalgebra
•
de Morgansche Gesetze
Grundlagen der Informatik
WS 2006/2007
Seite 69
Die boolesche Algebra wurde von dem Engländer George Boole 1854 entwickelt.
Ziel: Zweifelsfreie Feststellung der Wahrheit oder Falschheit von Aussagen.
Die Boolesche Algebra kennt zwei zulässige Zustände
wahr =
logisch 1 =
nicht wahr = logisch 0 =
Spannung vorhanden
keine Spannung
Sie beruht auf drei Basisoperationen
Negation
NICHT-Funktion
Konjunktion
UND-Funktion
Disjunktion
ODER-Funktion
Grundlagen der Informatik
WS 2006/2007
Seite 70
Definition Boolesche Algebra
⋅
Eine Menge M mit zwei Verknüpfungen und + heißt boolesche Algebra,
wenn für alle x, y, z
∈ M gilt:
Assoziativgesetz
⋅⋅
⋅ ⋅
x (y z) = (x y) z
x + (y+z) = (x+y) + z
Kommutativgesetz
⋅
⋅
x y=y x
x+y = y+x
Grundlagen der Informatik
WS 2006/2007
Seite 71
Verschmelzungsgesetz oder Absorptionsgesetz
⋅
x (x+y) = x
⋅
x + (x y) = x
Distributivgesetz
⋅
⋅
⋅
x (y+z) = (x y)+(x z)
⋅
⋅
x+(y z) =(x+y) (x+z)
⋅
es gibt ein Element 0 ∈ M mit 0 ⋅ x = 0 und 0 + x = x für alle x ∈ M
es gibt ein Element 1 ∈ M mit 1⋅ x = x und 1 + x = 1 für alle x∈ M
neutrales Element bzgl. + und
komplementäres Element
⋅
zu jedem x∈ M existiert genau ein y ∈ M mit x y = 0 und x + y = 1
Seite 72
Grundlagen der Informatik
WS 2006/2007
Grundlagen der Schaltalgebra
Die Schaltalgebra ist eine Anwendung der booleschen Algebra zur
Beschreibung und Untersuchung logischer Schaltungen.
M sei eine Menge mit zwei Elementen, die mit 0 und 1 oder O und L bezeichnet
werden.
Es gibt drei Basis-Verknüpfungen
Disjunktion
oder ODER-Funktion
mit den Symbolen + bzw.
Konjunktion
oder UND-Funktion
mit den Symbolen bzw.
Negation
oder NICHT-Funktion
mit den Symbolen
⋅
∨
∧ bzw. &
bzw.
¬
bzw.
Die DIN 40700 legt Schaltzeichen für die logischen Funktionen fest.
Grundlagen der Informatik
WS 2006/2007
Seite 73
Disjunktion bzw. ODER-Funktion
•
Die Disjunktion beschreibt eine logische ODER-Verknüpfung
•
Gleichung:
A = E1 ∨ E2 bzw. A = E1 + E2
•
Der Ausgang ist dann "wahr", wenn entweder E1 oder E2 "wahr" sind.
Wahrheitstabelle
E1 E2
0 0
0 1
1 0
1 1
A
0
1
1
1
Schaltzeichen
E1
E2
≥
A
Parallelschaltung
E1 o
S1
U0 > 0
o
•
E2 o
•
S2
o
R
Grundlagen der Informatik
WS 2006/2007
Seite 74
Konjunktion bzw. UND-Funktion
•
Die Konjunktion beschreibt eine logische UND-Verknüpfung
•
Gleichung:
A = E1 & E2 bzw. A = E1 ∧ E2 bzw. A = E1 E2 bzw. A = E1 E2
•
Wenn beide Eingänge "wahr" sind, dann ist auch der Ausgang "wahr"
⋅
U0 > 0
o
Wahrheitstabelle
E1 E2
0 0
0 1
1 0
1 1
Reihenschaltung
Schaltzeichen
A
0
0
0
1
E1
E2
&
A
E1
o
S1
E2
o
S2
•
oA
R
Grundlagen der Informatik
WS 2006/2007
Seite 75
Negation bzw. NOT-Funktion
•
Die Negation beschreibt eine logische NICHT-Verknüpfung
•
Gleichung:
A = E bzw. A = ¬E bzw. A = E
•
Wenn der Eingang "wahr" ist, dann ist der Ausgang "falsch"
Wahrheitstabelle
E
0
1
A
1
0
Schaltzeichen
E
1
o
A
Grundlagen der Informatik
WS 2006/2007
Seite 76
Weitere Verknüpfungen
•
NOT AND bzw. NAND
Wahrheitstabelle
Gleichung
⋅
A = E1 E2
•
NOT OR bzw. NOR
Gleichung: A = E1 + E2
E1 E2
0 0
0 1
1 0
1 1
A
1
1
1
0
E1 E2
0 0
0 1
1 0
1 1
A
1
0
0
0
Schaltzeichen
E1
&
o
A
≥1
o
A
E2
E1
E2
Grundlagen der Informatik
WS 2006/2007
Seite 77
Weitere Verknüpfungen
•
Antivalenz (Exklusives ODER) bzw. EXOR
Gleichung
Wahrheitstabelle
A = E1⊕ E2 = E1E2 + E1E2
•
E1 E2
0 0
0 1
1 0
1 1
Äquivalenz (Gleichheit) bzw. EXNOR
Gleichung: A = E1E2 + E1E2
E1 E2
0 0
0 1
1 0
1 1
A
0
1
1
0
A
1
0
0
1
Schaltzeichen
E1
E2
E1
E2
=1
A
=
A
Grundlagen der Informatik
WS 2006/2007
Seite 78
Einige Rechengesetze für beliebige boolesche Ausdrücke
de Morgansche Gesetze
i) A ∨ B =
ii ) A ∧ B =
A ∧ B
A ∨ B
weitere Gesetze
iii ) A ∨ A = A
iv ) A ∧ A = A
v ) A ∧ B ∨
A ∧ B = B
Grundlagen der Informatik
WS 2006/2007
Seite 79
4. Erstellung von Software – Anwendungsprogrammierung
Definition
Ein Programm ist eine Folge von Befehlen oder Anweisungen an eine
EDV-Anlage zur automatischen Bearbeitung eines Problems.
Zur Erstellung eines Programms sind die folgenden Komponenten
von Bedeutung: Editor, Compiler, Linker, Loader
Editor
• Erzeugt lesbare Textdateien in der jeweiligen Programmiersprache
Assembler
• Maschinenorientierte Programmiersprache
Zur Übersetzung des Quellcodes in die Maschinensprache des Rechners gibt
es zwei Typen von Übersetzungsprogrammen: Compiler und Interpreter
Grundlagen der Informatik
WS 2006/2007
Seite 80
Interpreter
•
Übersetzt immer nur eine einzige Programmanweisung in Maschinensprache
•
Jeder übersetzte Befehl wird sofort ausgeführt
•
Die Übersetzung wird nicht abgespeichert
Compiler
•
Übersetzt immer einen kompletten Programmtext in eine Folge von
Maschinenbefehlen, bevor die erste Programmanweisung ausgeführt wird
•
Erzeugt aus dem Quellcode durch einen Übersetzungsvorgang den
sogenannten Objektcode.
•
Überprüft auf Grammatik- oder Syntaxfehler
•
Objektcode enthält binären Code für einen speziellen Prozessor für ein
bestimmtes Quellcode-Modul
Grundlagen der Informatik
WS 2006/2007
Seite 81
Linker
•
Führt nach dem Compilieren mehrere unabhängige Programmteile
eines Softwareprojektes zu einem Gesamtprojekt zusammen
•
Hinzufügung benötigter mathematischer oder anderer allgemeiner
Programmteile aus Softwarebibliotheken
•
Erzeugt aus den Objektcode des Programmierers und dem
Objektcode der Bibliothek ausführbaren Programmcode.
Loader
•
Lädt das Programm an eine freie Position im RAM
•
Funktion wird in der Regel durch das Betriebssystem bereitgestellt.
Grundlagen der Informatik
WS 2006/2007
Seite 82
Zur Entstehung eines lauffähigen Compiler-Programms sind also
folgende Schritte notwendig:
Editor
Quellcode
Quellcode
Compiler
Objektcode
Objektcode
Objektcode
Objektcode
BibliotheksBibliothekscode
code
Linker
ProgrammProgrammcode
code
Loader
Lauffähiges
Programm
im Speicher
Grundlagen der Informatik
WS 2006/2007
Seite 83
Hilfsmittel zur Softwareentwicklung sind:
Debugger
•
System zur Identifizierung von logischen u. Laufzeit - Fehlern
•
Debugger drängen sich zwischen Betriebssystem und Programm und
übernehmen die Steuerung und Kontrolle der Programmausführung.
IDE - Integrated Development Environment
•
Entwicklungsumgebung, die sämtliche Schritte der
Programmentwicklung von einer gemeinsamen Entwicklungsoberfläche
möglich macht.
•
Ermöglicht die graphische Entwicklung von Software
•
Verbirgt die Komplexität der Entwicklung
Grundlagen der Informatik
WS 2006/2007
Seite 84
Programmiersprachen – Übersicht (Auswahl)
Fortran
1960
ALGOL
Basic
Lisp
1965
COBOL
PL/1
Simula
1970
Pascal
C
1975
1980
Modula 2
Prolog
Smaltalk
Ada
1985
Object Pascal
1990
Delphi
1995
Ada 95
ABAP
C++
CLOS
Java
2000
Prozedurale
Sprache
Objektorientiert Sprache
KI Sprache
Business
Sprache
Grundlagen der Informatik
WS 2006/2007
Seite 85
4. Softwareentwicklung mit Java
•
Grundlagen von Java
•
Datentypen
•
Kontrollstrukturen
•
Methoden
•
Grundlagen der Objektorientierung
•
Klassen, Objekte
•
Zugriffschutz
•
Kapselung
•
Vererbung
•
Ausnahmebehandlung
•
Die Klassen Object, String, StringBuffer
Grundlagen der Informatik
WS 2006/2007
Seite 86
Kurze Einführung in die Geschichte von Java
•
Java wurde ab 1991 von der Firma Sun Microsystems entwickelt.
•
Zu Beginn erfolgte die Entwicklung im Rahmen eines internen
Forschungsprojektes mit dem Ziel, eine Programmiersprache zur
Steuerung von Geräten der Haushaltselektronik zu entwickeln.
•
Hauptziel der Programmiersprache: klein, schnell, effizient und leicht
portierbar für breiten Bereich von Hardware.
•
Die Programmiersprache erhielt den Namen Java (Umgangssprachlich
Kaffee).
•
1993 sollte Projekt abgebrochen werden, da sich Markt für intelligente
Haushaltsgeräte nicht gut entwickelte.
•
Zu dieser Zeit etablierte sich das World Wide Web (WWW).
•
Sun erkannte Potential in Java und das Projekt wurde fortgeführt.
•
Anfang 1995: Durchbruch von Java durch Netscape Navigator 2.0, der
Java Programme ausführen kann.
Grundlagen der Informatik
WS 2006/2007
Seite 87
Das Arbeitsprinzip von Java
•
Der Source Code eines Java-Programms steht in einer Textdatei mit der
Endung .java
•
Von einem Compiler mit dem Namen javac wird anhand dieser Text-Datei eine
Datei mit der Endung .class erzeugt.
•
Diese Datei enthält den so genannten Bytecode, der auf einer virtuellen
Maschine (JVM) läuft. Dies ist ein Interpreter, der für jedes Betriebssystem den
Bytecode in den RAM des Rechners lädt und das Programm ablaufen lässt.
•
Die virtuelle Maschine wird durch den Befehl java aufgerufen und führt den
Bytecode aus.
•
Die JVM ist Teil der Java Runtime Environment (JRE), die es für jedes gängige
Betriebssystem gibt.
Grundlagen der Informatik
WS 2006/2007
Seite 88
Einige Eigenschaften von Java
Definition der Firma Sun:
Java ist eine einfache, objektorientierte, verteilte, interpretierte, stabile, sichere,
plattformunabhängige, portierbare, leistungs- und multithreadingfähige und
dynamische Sprache.
Grundlagen der Informatik
WS 2006/2007
Seite 89
Die Voraussetzung für das Arbeiten mit Java
•
Zur Erstellung von Java-Programmen benötigt man die Java 2 SDKUmgebung für das entsprechende Betriebssystem.
•
SDK = Software Development Kit
•
Das SDK beinhaltet die notwendigen Programme, insbesondere den
Compiler javac, den Interpreter java und die Virtuelle Maschine.
•
Das J2SE kann man im Internet direkt von SUN herunterladen. Die Adresse
lautet http://java.sun.com
•
Die Beschreibung der Installation findet man z.B. im Online-Tutorial
http://java.sun.com/docs/books/tutorial/index.html
oder z.B. in Jobst (2001), S. 13
Grundlagen der Informatik
WS 2006/2007
Seite 90
Erstellung von Java-Programmen
Java Programme werden als Text in Dateien eingegeben.
Hierzu benutzt man entweder
•
einen Texteditor oder
•
eine integrierte Entwicklungsumgebung (IDE Integrated Development
Environment).
Wir werden in der Vorlesung und im Praktikum mit einem Texteditor arbeiten.
Das JDK werden wir in der aktuellen Version 1.5 verwenden.
Grundlagen der Informatik
WS 2006/2007
Seite 91
Die vier Programmarten von Java
•
Applikationen (lat. für Anwendung)
eigenständiges Programm, das nur die virtuelle Maschine als Interpreter
braucht und selbstständig lauffähig ist (wie in anderen
Programmiersprachen üblich)
•
Applets (engl. für „kleine Applikation“)
Unterprogramm eines Webbrowsers, welcher die virtuelle Maschine als
Interpreter braucht.
Grundlagen der Informatik
WS 2006/2007
Seite 92
•
Servlets
Unterprogramm eines Webservers (Gegenstück zu einem Applet auf dem
Webclient = Browser)
• erweitert die Funktionalität eines Webservers
• eng verwandt: JSP (Java Server Pages), d.h. HTML-Seiten, in die Java
Programme eingebettet sind, welche bei Aufruf auf dem Server
ausgeführt werden.
• mögliche Anwendungen: sichere und vertrauliche Zugänge zu einer
Website, Zugriffe auf Datenbanken, dynamische Erstellung von HTMLSeiten
Grundlagen der Informatik
WS 2006/2007
Seite 93
•
Midlets (MID = mobile information device)
Java-Programm, das auf Mobilgeräten wie Handys oder Handhelds
ablaufen kann.
• ist geeignet für Geräte mit wenig Speicher, geringer Performanz,
temporären Verbindungen zum Netz
• Spezielle Entwicklungsumgebung von SUN: J2ME (Java 2 Micro
Edition), benötigt J2SDK
• Abgespeckte Virtuelle Maschine KVM (K für kilo, da der benötigte
Speicher im Kilobyte Bereich liegt)
• Weiter Informationen unter http://java.sun.com/j2me/
Grundlagen der Informatik
WS 2006/2007
Seite 94
Auszug aus der Java - Literatur
•
Helmut Erlenkötter: Java. Programmieren von Anfang an. Rohwohlt
Taschenbuch Verlag.
•
Joachim Goll, Cornelia Weiß, Frank Müller: Java als erste
Programmiersprache. B.G. Teubner.
•
Fritz Jobst: Einführung in Java. Fachbuchverlag Leipzig.
•
Christian Ullenboom: Java ist auch eine Insel. Galileo Press, Bonn.
Links
•
Java Tutorial von SUN http://java.sun.com/docs/books/tutorial
•
Guido Krüger, Handbuch der Java-Programmierung http://www.javabuch.de
•
Christian Ullenbooms Online-Buch http://java-tutor.com/javabuch/index.htm
Grundlagen der Informatik
WS 2006/2007
Seite 95
Einfache Java-Applikationen
// Willkommen.java
/*
Ausgabe eines Textes
*/
class Willkommen{
public static void main (String args[]){
System.out.println ("Willkommen zur Java-Vorlesung");
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 96
Was sind die Schritte, um die Applikation zu Starten?
1. Erstellen der Datei Willkommen.class im Bytecode:
javac Willkommen.java
2.
java Willkommen führt zur Ausführung des Programms
Das Ergebnis ist die Ausgabe des Textes
Grundlagen der Informatik
WS 2006/2007
Seite 97
Grundbestandteile eines Java-Programms
1. Ein Java Programm ist stets eine Klasse und beginnt mit dem
Schlüsselwort class und dem Namen der Klasse.
2. Ein Java-Programm ist in Einheiten gepackt, so genannte Blöcke, die von
geschweiften Klammern {...} umschlossen sind.
3. Der Startpunkt jeder Applikation ist die Methode main(). Hier beginnt der
Java-Interpreter (die „virtuelle Maschine“) die einzelnen Anweisungen
auszuführen. Abgearbeitet wird sequenziell, d.h. der Reihe nach.
4. Die Applikation Willkommen.java besteht aus einer Anweisung, der
Ausgabe eines Textes.
Grundlagen der Informatik
WS 2006/2007
Seite 98
Kommentare
Kommentare dienen zur Dokumentation von Programmen und Verbessern ihre
Lesbarkeit. Sie bewirken keine Aktion bei der Ausführung des Programms und
werden vom Java-Compiler ignoriert.
Es gibt drei verschiedene Arten, Kommentare in Java zu erstellen.
//.. einzeiliger Kommentar, beginnt mit dem Doppelslash // und endet mit
dem Zeilenende (Quellcode, der in derselben Zeile vor dem Doppelslash steht,
wird normal verarbeitet)
/*...*/ Kommentierung von mehreren Textzeilen
/**...*/ Dokumentationskommentar zur automatischen Dokumentation
Grundlagen der Informatik
WS 2006/2007
Seite 99
Empfehlung:
Jedes Programm sollte mit einem Kommentar beginnen, der den
Klassennamen beinhaltet, die Version, das Datum und den Zweck des
Programms beschreibt.
/*
*Classname
*
*Versioninformation
*
*Date
*
*Copyrightnotice
*/
Leerzeilen, Leerzeichen und Tabstops werden vom Java-Compiler nicht
verarbeitet. Sie sollten verwendet werden zur Strukturierung und Lesbarkeit des
Programms.
Grundlagen der Informatik
WS 2006/2007
Seite 100
Die Klassendeklaration
•
Jedes Java-Programm besteht aus mindestens einer Klasse
•
Das reservierte Wort class eröffnet die Klassendeklaration in Java, gefolgt
von dem Klassennamen (in unserem ersten Beispiel Willkommen)
•
Reservierte Wörter sind von Java belegt (nur kleine Buchstaben)
•
Der Klassenname ist ein Identifier oder Bezeichner
•
Ein Identifier ist eine Folge von alphanumerischen Zeichen, d.h.
Buchstaben, Ziffern, dem Unterstrich_ und dem $ Zeichen
•
Ein Bezeichner darf nicht mit einer Ziffer beginnen und keine Leerzeichen
enthalten
•
Java ist case sensitive, d.h. Groß- und Kleinschreibung wird unterschieden
Grundlagen der Informatik
WS 2006/2007
Seite 101
Merkregel für das Erstellen einfacher Applikationen
Speichern Sie zunächst Ihre Klasse in einer Datei ab, die genau so heißt, wie
die Klasse mit der Erweiterung „.java“.
Es gilt folgende Konvention:
Klassennamen beginnen mit einem Großbuchstaben und bestehen aus einem
Wort.
Grundlagen der Informatik
WS 2006/2007
Seite 102
Blöcke
•
Die Deklaration einer Klasse geschieht in einem Block, der durch
geschweifte Klammern {} umschlossen ist
•
Innerhalb eines Blockes können sich noch weitere Blöcke befinden
•
Die Klammern müssen korrekt geschlossen sein.
Zwei Konventionen sind üblich
class Willkommen
{
....
}
oder die bei Java bevorzugte Konvention
class Willkommen {
.....
}
Grundlagen der Informatik
WS 2006/2007
Seite 103
Der Programmstart: Die Methode main
•
Die zentrale Einheit einer Applikation ist die Methode main.
•
Durch sie wird die Applikation gestartet, durch die dann alle Anweisungen
ausgeführt werden, die in ihr programmiert sind.
•
Die Zeile public static void main ( String args[] )
ist Teil jeder Java-Applikation.
•
Java-Applikationen beginnen automatisch bei main.
•
Die runden Klammern hinter main() zeigen an, dass main eine Methode
ist.
•
Nach dem Aufruf der Methode main mit dem Standardargument String
args[] kommt der Methodenrumpf, eingeschlossen durch geschweifte
Klammern ({...}).
Grundlagen der Informatik
WS 2006/2007
Seite 104
Eine allgemeine Applikation in Java muss in jedem Fall die folgende
Konstruktion beinhalten
class Klassenname {
public static void main( String args[] ){
Deklarationen und Anweisungen;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 105
Erweiterung der ersten Java-Applikationen
/*
Ausgabe eines Textes in einem Dialogfenster
*/
import javax.swing.JOptionPane;
class Willkommen2{
public static void main (String args[]){
JOptionPane.showMessageDialog (null,
"Willkommen zur \nJava-Vorlesung");
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 106
Die Ausgabe erfolgt dann in einem Dialogfenster,
das durch das Klicken des OK Buttons geschlossen werden kann.
Grundlagen der Informatik
WS 2006/2007
Seite 107
Die Methode System.exit
•
Die Methode exit() gehört zur Klasse System und beendet die
Applikation bei Dialogfenstern.
•
Wird diese Anweisung bei Dialogfenstern nicht angegeben, so blockiert die
Applikation die Java Virtual Maschine.
•
Die Klasse System gehört zu dem Paket java.lang, das automatisch
jedem Java-Programm zur Verfügung steht.
Grundlagen der Informatik
WS 2006/2007
Seite 108
Die import-Anweisung
•
Benutzt man Klassen aus anderen Paketen (Ausnahme bildet das Paket
java.lang) so muss diese Klasse ausdrücklich mit ihrem Paketpfad
angegeben werden.
•
Mit der import-Anweisung wird die Klasse JOptionPane eingelesen und für
das Programm benutzbar.
• JOptionPane ist eine Standardklasse von Java aus dem Paket
javax.swing und stellt Dialogboxen, d.h. Fenster zur Ein-und Ausgabe
zur Verfügung.
•
Java-Klassen können generell in Paketen, d.h. in Verzeichnissen
bereitgestellt werden. Z.B. sind alle Klassen des Swing-Pakets
javax.swing in dem Verzeichnis \javax\swing zu finden
Grundlagen der Informatik
WS 2006/2007
Seite 109
•
Die Methode showMessageDialog() öffnet eine Dialogbox, die den in
Hochkommata eingeschlossenen Text anzeigt, der an zweiter Stelle, d.h.
nach dem reservierten Wort null steht.
• null ist ein reserviertes Wort. null ist der Bezeichner für ein nicht
vorhandenes Objekt. In unserem Fall bewirkt es, dass ein Standard-Frame
benutzt wird, der zentriert auf der Mitte des Bildschirms erscheint. (Mit der
Erstellung von Frames beschäftigen wir uns im zweiten Semester).
Grundlagen der Informatik
WS 2006/2007
Seite 110
Escape-Sequenzen und Strings
•
Der in die Anführungszeichen (" ") gesetzte Text ist ein String, d.h. eine
Kette von beliebigen Zeichen
•
Strings sind in Java vom Datentyp String
•
Strings werden z. B. durch die Methoden System.out.println() oder
JOptionPane.showMessageDialog() auf dem Bildschirm exakt so
ausgegeben, wie eingetippt- bis auf die sogenannten Escape-Sequenzen:
•
Eine Escape-Sequenzen ist ein Hilfsmittel zur Darstellung nicht druckbarer
Zeichen und wird durch den Backslash (\) gefolgt von genau einem
weiteren Zeichen, z.B. \n für einen Zeilenwechsel, geschrieben.
Grundlagen der Informatik
WS 2006/2007
Seite 111
Escape-Zeichen
Bedeutung
\n
neue Zeile (new line)
\t
führt Tabulatorsprung aus (tab)
\r
positioniert den Cursor an den Anfang der aktuellen
Zeile (carriage return)
\b
positioniert den Cursor ein Zeichen zurück (backspace)
\f
Seitenvorschub (neue Seite) (form feed)
\\
Ausgabe des Backslash \
\"
Ausgabe der Anführungszeichen
\‘
Ausgabe der Hochkomma
Grundlagen der Informatik
WS 2006/2007
Seite 112
Anmerkung zu den Escape-Sequenzen
Die Escape-Sequenzen \t, \f, \r und \b werden von der Methode
showMessageDialog() nicht beachtet.
Grundlagen der Informatik
WS 2006/2007
Seite 113
Programmier-Styleguide
Als Programmierstil hat sich durchgesetzt:
Variablennamen
Kleinbuchstaben
variable
Methodennamen
Kleinbuchstaben
methode( )
Klassennamen
1. Buchstabe groß, Rest klein
Willkommen
Aus mehreren Wörtern zusammengesetzte Namen werden ohne Unterstrich
geschrieben, dabei wird ab dem zweiten Wort jeweils der erste Buchstabe
eines Wortes groß geschrieben. Für das erste Wort gilt die normale
Konvention.
Beispiel: dritteWurzel
addiereWerte ( )
Variable
Methode
Grundlagen der Informatik
WS 2006/2007
Seite 114
Reservierte Schlüsselwörter
Bestimmte Wörter sind als Bezeichner nicht zulässig, da sie als
Schlüsselwörter durch den Compiler besonders behandelt werden.
Schlüsselwörter bestimmen die „Sprache“ eines Compilers.
Grundlagen der Informatik
WS 2006/2007
Seite 115
Folgende Schlüsselwörter gibt es in Java:
abstract, boolean, break, byte, case, catch, char, class,
const *), continue, default,do, double, else, extends,
final, finally, float, for, goto *), if, implements,
import, instanceof, int, interface, long, native, new,
package, private, protected, public, return, short,
static, strictfp,super, switch, synchronized,this, throw,
transient, try, void, volatile, while.
*) Diese Schlüsselwörter sind reserviert, werden aber nicht benutzt.
Grundlagen der Informatik
WS 2006/2007
Seite 116
String Addition
Strings können durch den Verkettungsoperator + verknüpft werden.
Durch diesen Operator werden zwei Strings aneinander gereiht.
Im nächsten Beispiel werden zwei einzugebende Strings aneinander gefügt.
Grundlagen der Informatik
WS 2006/2007
Seite 117
// StringAddition.java
//Fuehrt zwei einzugebende Strings zusammen
import javax.swing.JOptionPane;
class StringAddition {
public static void main(String args[]){
String ersteEingabe, zweiteEingabe;
String ausgabe;
//Einlesen des ersten Textes:
ersteEingabe = JOptionPane.showInputDialog("Geben
Sie einen Text ein");
zweiteEingabe = JOptionPane.showInputDialog("Geben
Sie einen zweiten Text ein");
//Zusammenfuehrung beider Texte
ausgabe = ersteEingabe + zweiteEingabe;
//Ausgabe des zusammengefuegten Textes
JOptionPane.showMessageDialog(null, ausgabe, "Ergebnis",
JOptionPane.PLAIN_MESSAGE);
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 118
Die Ein- und Ausgabe erfolgt dann in folgenden Dialogfenstern
Grundlagen der Informatik
WS 2006/2007
Seite 119
Eingabedialoge
Die Methode JOptionPane.showInputDialog mit dem String("Geben
Sie einen Text ein")erzeugt das folgende Fenster:
Der Anwender muss einen String eingeben, der mit der Return-Taste oder mit
einem Mausklick auf den OK-Button beendet wird.
Über dem Eingabefeld erscheint der Text, der der Methode im Programm
mitgegeben wurde.
Der eingegebene String wird durch die Methode an das Programm zurück
gegeben.
Grundlagen der Informatik
WS 2006/2007
Seite 120
Ausgabe-Dialoge
Die Methode
JOptionPane.showMessageDialog(null, ausgabe, "Ergebnis",
JOptionPane.PLAIN_MESSAGE);
erzeugt das Fenster.
Hier hat die Methode 4 Argumente:
1.
null
Standard-Frame (keine Bindung an ein Fenster)
2.
ausgabe
Nachricht, die angezeigt werden soll
3.
"Ergebnis"
String in der Titelleiste
4.
JOptionPane.PLAIN_MESSAGE Bestimmt Anzeige des Message-Dialogtyps
Grundlagen der Informatik
WS 2006/2007
Seite 121
Zusammenstellung der Message-Dialogtypen
Message-Dialogtyp
Icon
Bedeutung
JOptionPane.ERROR_MESSAGE
Fehlermeldung
JOptionPane.INFORMATION_MESSAGE
informative Meldung;
der User kann sie nur
wegklicken
JOptionPane.WARNING_MESSAGE
Warnmeldung
JOptionPane.QUESTION_MESSAGE
Fragemeldung
JOptionPane.PLAIN_MESSAGE
Meldung ohne Icon
Grundlagen der Informatik
WS 2006/2007
Seite 122
Variablen, Datentyp, Deklaration
•
Allgemein sind Variablen Platzhalter bzw. Speicherbereiche.
•
Variablen können eine bestimmte Menge von Werten annehmen. Diese
Menge bezeichnet man als Datentyp.
•
Eine Deklaration Datentyp variablenName ordnet der Variable mit dem
Namen variablenName einen bestimmten Datentyp zu.
•
Eine Variable wird deklariert, indem man zuerst ihren Typ angibt und
dahinter ihren Namen schreibt.
•
Variablen müssen stets deklariert sein, bevor sie verwendet wird.
•
Durch die Deklaration wird ein bestimmter Speicherplatz im RAM reserviert.
Grundlagen der Informatik
WS 2006/2007
Seite 123
Beispiel für eine Deklaration: int a;
Gibt es in einem Programm mehrer Variablen des selben Datentyp, so kann
man deren Namen bei der Deklaration durch Kommata getrennt hinter den
Datentyp setzten:
Beispiel: int a, b;
Grundlagen der Informatik
WS 2006/2007
Seite 124
Wertzuweisungen
In der Applikation StringAddition sind die Ausdrücke
ersteEingabe = JOptionPane.showInputDialog
("Geben Sie einen Text ein");
zweiteEingabe = JOptionPane.showInputDialog
("Geben Sie einen zweiten Text ein");
ausgabe = ersteEingabe + zweiteEingabe;
Wertzuweisungen.
= ist der Zuweisungsoperator
Grundlagen der Informatik
WS 2006/2007
Seite 125
Die Variable ersteEingabe bekommt den String zugewiesen, den der User
eingegeben hat.
Nach der Belegung der Variable durch den String, hat das Programm den
eingegebenen Wert im Hauptspeicher.
Die Anweisung
ausgabe = ersteEingabe + zweiteEingabe;
weist der Variablen ausgabe die Aneinanderreihung der beiden Strings zu.
Grundlagen der Informatik
WS 2006/2007
Seite 126
Die Applikation Zahlen addieren
In der Applikation IntAddition sollen zwei ganze Zahlen über die Tastatur
eingelesen und die Summe berechnet und ausgegeben werden.
Ganze Zahlen sind in Java vom Datentyp int (integer).
Grundlagen der Informatik
WS 2006/2007
Seite 127
// IntAddition.java
//Addiert zwei einzugebende ganze Zahlen
import javax.swing.JOptionPane;
class IntAddition{
public static void main (String args[]){
//Variablendeklaration
String ersteEingabe,
//1. Eingabestring
zweiteEingabe; //2. Eingabestring
int zahl1,
zahl2,
summe;
//1. zu addierende Zahl
//2. zu addierende Zahl
//Summe von zahl1 und zahl2
Grundlagen der Informatik
WS 2006/2007
Seite 128
//Einlesen der ersten Zahl als String:
ersteEingabe = JOptionPane.showInputDialog("Geben Sie
die erste ganze Zahl ein");
zweiteEingabe = JOptionPane.showInputDialog("Geben Sie
die zweite ganze Zahl ein");
//Konvertierung der Eingabe von String nach int:
zahl1 = Integer.parseInt(ersteEingabe);
zahl2 = Integer.parseInt(zweiteEingabe);
//Addition der beiden Zahlen:
summe = zahl1 + zahl2;
//Ausgabe
JOptionPane.showMessageDialog(null,
"Die Summe ist " + summe,
"Ergebnis",JOptionPane.PLAIN_MESSAGE);
System.exit ( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 129
Die Applikation liefert folgende Ergebnisse
Grundlagen der Informatik
WS 2006/2007
Seite 130
Datentypen und Typkonvertierung
Anmerkungen zu der Applikation IntAddition
•
Die Methode showMessageDialog() kann nur Strings einlesen und auch
nur Strings an das Programm weitergeben.
•
Jede Eingabe von der Tastatur ist daher ein String, d.h. auch wenn 5
eingetippt wird, ist 5 keine Zahl sondern ein String.
•
Sind 5 und 11 Zahlen, so ergibt 5 + 11 den Wert 16.
Sind 5 und 11 Strings, so ergibt "5 " + " 11 " den String "511"
•
Zahlen werden durch + arithmetisch addiert,
Strings werden aneinandergereiht.
Grundlagen der Informatik
WS 2006/2007
Seite 131
•
Da über die Tastatur die Eingabe als String erfolgt, müssen die Strings in
Integer Zahlen konvertiert (umgewandelt) werden.
•
Für die Typumwandlung von String in eine Integer-Zahl gibt es in Java die
Methode parseInt(). Dies ist eine Methode der Klasse Integer aus
dem Paket java.lang. Beispiel:
zahl1 = Integer.parseInt(ersteEingabe);
•
Die Zeile
summe = zahl1 + zahl2;
besteht aus den zwei Operationen = und +. Der Operator + addiert die
Werte der beiden Zahlen, der Zuweisungsoperator = weist diesen Wert der
Variablen summe zu.
Grundlagen der Informatik
WS 2006/2007
Seite 132
•
Das Ergebnis wird ausgegeben:
"Die Summe ist " + summe
"Die Summe ist " ist ein String, summe eine Integer-Zahl.
String + Zahl ergibt String, d.h. der + Operator reiht die Strings aneinander.
summe wird automatisch in einen String konvertiert.
Man nennt dies automatische Typanpassung oder implizite Typkonvertierung
oder implizites Typcasting.
Grundlagen der Informatik
WS 2006/2007
Seite 133
Die Primitiven bzw. elementaren Datentypen
•
Variablennamen wie zahl1 und zahl2 beziehen sich auf bestimmte
Stellen im Arbeitsspeicher des Rechners.
•
Jede Variable hat einen Namen, einen Typ, eine Größe und einen Wert.
•
Bei der Deklaration einer Variablen werden bestimmt Speicherzellen
reserviert.
•
Der Name der Variable im Programmcode verweist während der Laufzeit
auf die Adresse dieser Speicherzellen
•
Die primitiven Datentypen bzw. elementaren Datentypen bekommen
standardmäßig die folgenden Speichergrößen zugewiesen:
Grundlagen der Informatik
WS 2006/2007
Seite 134
S c h lü s se lw ort
S p eich e rpla tz
W erteb ereich
Datentypen für ganzzahlige Werte (mit Vorzeichen)
byte
8 Bit
-128..127
short
16 Bit
-32768..32767
int
32 Bit
-2 ..2 -1
long
64 Bit
-2 ..2 -1
Datentypen für Gleitkommazahlen
float
32 Bit
double
64 Bit
31
31
63
63
- 3.40292347E+38 bis
+ 3.40292347E+38
- 1.7976313486231570E+308 bis
+ 1.7976313486231570E+308
Datentypen für Boolesche Werte
boolean
1 Bit
false, true
Datentypen für Unicode-Textzeichen
char
16 Bit
\u0000…\uFFFF
Grundlagen der Informatik
WS 2006/2007
Seite 135
Der primitive Datentyp char
-
Eine Zeichenkonstante ist ein Zeichen, eingeschlossen in einfache
Anführungszeichen. Beispiel char c = 'a';
-
In Java ist eine Zeichenkonstante vom Typ char
-
Ein char ist nicht vorzeichenbehaftet
-
Der Datentyp char ist 2 Byte groß und nimmt ein Unicode-Zeichen auf.
-
Mit Zeichenkonstanten kann man rechnen wie mit ganzen Zahlen
-
Man kann sie in ganzzahligen Ausdrücken verwenden
-
Beispiel: Zeichen '1' hat im Unicode-Zeichensatz den Wert 49
Grundlagen der Informatik
WS 2006/2007
Seite 136
// Zeichen.java
// Rechnen mit dem Datentyp char
class Zeichen{
public static void main (String args[]){
int b, f, g, h;
char c, d, e;
b = 5;
c = '1';
d = 'A';
e = 66;
f = b + c;
g = c + d;
h = b + d;
System.out.println ("b = "+ b +" \nc = "+ c + "\nd = "+ d);
System.out.println ("e = "+ e +"\nf = "+ f + "\ng = "+ g );
System.out.println ("h = "+ h );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 137
Zeichen.java liefert die Ausgabe
Bemerkung:
Das Zeichen '0' hat in Unicode den Wert 48, 'A' hat den Unicode
Wert 65.
Grundlagen der Informatik
WS 2006/2007
Seite 138
Typanpassungen (Casting) bei elementaren Datentypen
Müssen Datentypen konvertiert (umgewandelt) werden, so bezeichnet man
dies als Typanpassung.
Java unterscheidet zwei Arten von Typanpassung:
•
Automatische Typanpassung
Daten eines kleineren Datentyps werden automatisch dem größeren
angepasst.
•
Explizite Typanpassung
Ein größerer Typ kann einem kleineren Typ nur mit Verlust von
Informationen zugewiesen werden.
Zwischen dem elementaren Datentyp boolean und den anderen elementaren
Datentypen findet keine Typanpassung statt.
Grundlagen der Informatik
WS 2006/2007
Seite 139
Typumwandlungen in einen „breiteren“ Datentyp
Der Wert ist immer darstellbar. Es kann allerdings an Genauigkeit verloren
gehen, z.B. bei der Umwandlung von int nach float.
von Datentyp
in Datentyp
byte
short, int, long, float, double
short
int, long, float, double
char
int, long, float, double
int
long, float, double
long
float, double
float
double
Grundlagen der Informatik
WS 2006/2007
Seite 140
•
Werte der Datentypen byte und short werden bei Rechenoperationen
automatisch in den Datentyp int umgewandelt.
•
Ist ein Operand vom Datentyp long, dann werden alle Operanden auf
long gesetzt.
Beispiele für die automatische Typanpassung:
1. Beispiel int b = 7; double c = b; ergibt c = 7.0
2. Beispiel long a, b = 6; int c = 3;
a = b +c; wandelt automatisch alle Operanden in den Datentyp long um.
Grundlagen der Informatik
WS 2006/2007
Seite 141
Explizite Typanpassung
Regel: Der gewünschte Typ für eine Typanpassung wird vor den
umzuwandelnden Datentyp geschrieben. Der Zieldatentyp ist dabei
geklammert, d.h. (Typname) ausdruck
Beispiele: int n = (int) 5.316;
int m = (int) (4.315 + 1.66);
Bei der Konvertierung eines größeren Ganzzahltyps in einen kleineren
werden die oberen Bits abgeschnitten.
Beispiel: int i = 385; byte a= (byte) i; ergibt a = -127
Grundlagen der Informatik
WS 2006/2007
Seite 142
Bei der Umwandlung von Gleitpunktzahlen in Ganzzahlen kann es zum
Verlust von Genauigkeit kommen.
Die Stellen hinter dem Komma (Punkt) werden abgeschnitten.
Bei zu großen Zahlen ist ein korrektes Ergebnis nicht möglich.
Beispiel double i = 345.886; int a = (int) i; ergibt a = 345;
Grundlagen der Informatik
WS 2006/2007
Seite 143
Die Umwandlung von short in char oder umgekehrt ist nur mit Hilfe der
expliziten Typumwandlung möglich (obwohl beide Länge 16 Bit haben).
Dies liegt am Vorzeichen von short. char hat kein Vorzeichen.
Der Wert von positiven Zahlen bleibt bei der Konvertierung erhalten.
Beispiel: short i = 48; char a =
(char) i; ergibt a = '0'
Grundlagen der Informatik
WS 2006/2007
Seite 144
Arithmetische Operationen:
Die Grundrechenoperationen in Java
Die Grundrechenoperationen bestehen aus einem Operator und zwei Operanden
(z.B. Operation 1 + 2 hat Operator + und Operanden 1 und 2).
Allgemein ist eine Operation gegeben durch einen Operator und mindestens einen
Operanden.
Operationen mit dem selben Operator aber unterschiedlichen Datentypen können
zu verschiedenen Ergebnissen führen
(Beispiel die Stringaddition "1" + "2" liefert anderes Ergebnis als die IntegerAddition 1 + 2).
Grundlagen der Informatik
WS 2006/2007
Seite 145
// Arithmetik.java
// Führt verschiedene arithmetische Operationen durch
class Arithmetik {
public static void main (String args[]){
int a,b,c,d; //ganze Zahlen
double x,y,z;
//reelle Zahlen
String ausgabe;
a = 6 * (3 - 1); b = 6 * 3 + 5;
x = 16 / 5; y = 16 / 5.0; z = 16.0 / 5;
c = 16 / 5; d = 16 % 5;
ausgabe = "Das Ergebnis ist:\na = "+ a + "\nb = "+ b;
ausgabe = ausgabe + "\nx = "+ x + "\ny = "+ y + "\nz = "+ z;
ausgabe = ausgabe + "\nc = "+ c + "\nd = "+ d;
System.out.println (ausgabe);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 146
Grundlagen der Informatik
WS 2006/2007
Seite 147
Der Additionsoperator A + B
Wendet man den zweistelligen Additionsoperator auf seine Operanden an, so
ist der Rückgabewert die Summe der Werte der beiden Operanden
Beispiel: int a = 6 + (3 + 4); ergibt a = 13
Der Subtraktionsoperator A – B
Wendet man den zweistelligen Subtraktionsoperator auf die Operanden A und
B an, so ist der Rückgabewert die Differenz der Werte der beiden Operanden.
Beispiel: int a = 16 - (3 - 4); ergibt a = 17
Grundlagen der Informatik
WS 2006/2007
Seite 148
Der Multiplikationsoperator A * B
Der Operator multipliziert den Wert A mit dem Wert B. Es gelten die normalen
Rechenregeln, d.h. Klammer vor Punktrechnung vor Strichrechnung.
Beispiel: int a = 6 * (3 + 4); ergibt a = 42
Grundlagen der Informatik
WS 2006/2007
Seite 149
Der Divisionsoperator A / B
Bei Nutzung des Divisionsoperators muss eine Fallunterscheidung
durchgeführt werden:
Erster Fall: A und B sind beide ganzzahlig.
Man spricht bei A / B von einer ganzzahlige Division.
Das Ergebnis A / B ist wieder eine ganze Zahl. Der Nachkommateil des
Ergebnisses wird abgeschnitten.
Beispiel: int c = 16 / 5; ergibt c = 3
Dabei bestimmt sich der Quotient vom Betrag her nach der Vorschrift, dass der
Quotient die größtmögliche ganze Zahl ist, für die gilt:
|Quotient * Nenner| <= |Zähler|
Grundlagen der Informatik
WS 2006/2007
Seite 150
Der Divisionsoperator A / B
Zweiter Fall:
A und/oder B sind Gleitpunktzahlen, d.h. vom Typ float oder double.
Das Ergebnis ist dann eine Gleitpunktzahl.
Beispiel: double d = 16.0 / 5; ergibt c = 3.2
Grundlagen der Informatik
WS 2006/2007
Seite 151
•
Division durch 0
•
Sind beide Operanden ganze Zahlen (z.B. 3/0), so ergibt sich beim
Interpretieren die Meldung
•
Ist einer der Operanden eine Gleitpunktzahl, so ergibt sich als Ergebnis
Infinity mit Berücksichtigung des Vorzeichens
Beispiel double x = -4.0 / 0 ergibt x = -Infinity
double x =
4.0 / 0 ergibt x =
Infinity
Null durch Null ergibt NaN (Not a number)
Beispiel 0.0 / 0.0 = NaN
Grundlagen der Informatik
WS 2006/2007
Seite 152
Der Restwertoperator A % B
Der Restwertoperator oder Modulo-Operator gibt den Rest der ganzzahligen
Division A / B an.
Das Ergebnis A % B ergibt sich aus A – (A / B) * B.
Das Ergebnis von A % B kann nur negativ sein, wenn der Zähler A negativ ist,
es kann nur positiv sein, wenn der Zähler A positiv ist.
Beispiele: (-9) % 2 =
-1
denn (-9) / 2 = -4
(-9) % (-2) = -1 denn (-9)/ (-2) = 4
9 % (-2) = 1
denn 9 / (-2) = -4
9 % 2 = 1
denn 9 / 2 = 4
Grundlagen der Informatik
WS 2006/2007
Seite 153
Rechenreihenfolge (Präzedenz) der arithmetischen Operatoren
Operator
Operation
Präzedenz
()
Klammern
werden zuerst ausgewertet.
Sind Klammern von Klammern
umschlossen, werden sie von innen
nach außen ausgewertet.
*, /, %
Multiplikation,
Division,
Modulus
werden als zweites ausgewertet
+, -
Addition,
Subtraktion
werden zuletzt ausgewertet
Grundlagen der Informatik
WS 2006/2007
Seite 154
Spezielle arithmetische Operatoren
Zuweisungsoperator
Beispiel
Bedeutung
+=
c += x
c=c + x
-=
c -= x
c=c - x
*=
c *= x
c = c * x
/=
c /= x
c = c / x
%=
c %= x
c = c % x
Grundlagen der Informatik
WS 2006/2007
Seite 155
Inkrementoperator ++ und Dekrementoperator -Operator
Beispiel
Bedeutung
++
++c
erhöht c um 1, bevor der neue Wert von c in dem
Ausdruck verwendet wird, in dem sich c befindet
++
c++
verwendet den aktuellen Wert von c in dem
Ausdruck, in dem sich c befindet, und erhöht erst
dann c um 1
--
--c
erniedrigt c um 1, bevor der neue Wert von c in
dem Ausdruck verwendet wird, in dem sich c
befindet
--
c--
verwendet den aktuellen Wert von c in dem
Ausdruck, in dem sich c befindet, und erniedrigt
erst dann c um 1
Da die Operatoren ++ und – nur einen Operanden haben, heißen sie unär.
Grundlagen der Informatik
WS 2006/2007
Seite 156
Was liefert die folgende Applikation für eine Ausgabe?
class Inkrement{
public static void main (String args[]){
int c;
String ausgabe ;
c = 5;
ausgabe = c + ", ";
ausgabe += c++ + ", ";
ausgabe += c + "\n";
c = 5;
ausgabe += c + ", ";
ausgabe += ++c + ", ";
ausgabe += c + "\n";
c = 5;
ausgabe += c + ", ";
ausgabe += --c + ", ";
ausgabe += c;
System.out.println(ausgabe);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 157
Kontrollstrukturen
Eine Kontrollstruktur ist eine Abfolge von Anweisungen.
Jedes Programm kann mit Hilfe von drei Kontrollstrukturen geschrieben werden:
1. Sequenz (sequence structure)
2. Auswahl oder Selektion (selection structure)
3. Wiederholung oder Schleife (repetition structure)
Grundlagen der Informatik
WS 2006/2007
Seite 158
Die Sequenz - Blöcke
Die Sequenz ist eine einfache Abfolge von Anweisungen. Diese Anweisungen
werden in Form eines Blockes zusammengefasst.
{
Anweisung 1;
Anweisung n;
}
Anweisung 1
Die Darstellung der Sequenz
als Struktogramm:
Anweisung n
Grundlagen der Informatik
WS 2006/2007
Seite 159
Die Auswahl- oder Selektionsstruktur
Die Selektion ermöglicht die Abarbeitung von Anweisungen in Abhängigkeit von
einer Bedingung.
In Java unterscheidet man zwischen der
•
einfachen Alternative mit if und else und der
•
mehrfachen Alternative mit else if oder switch.
Grundlagen der Informatik
WS 2006/2007
Seite 160
Die Selektion: Einfache Alternative – if und else
Als Struktogramm kann die Selektionsstruktur mit der einfachen Alternative wie
folgt dargestellt werden:
Bedingung
wahr
falsch
Anweisung a1
Anweisung b1
Anweisung an
Anweisung bm
Ist die Bedingung wahr, so wird der Block Anweisung a1 … Anweisung an
ausgeführt.
Ist die Bedingung falsch, so wird der Block Anweisung b1 … Anweisung bm
ausgeführt.
Grundlagen der Informatik
WS 2006/2007
Seite 161
Die Syntax der Selektion mit einfacher Alternative lautet in Java
if (Bedingung) {
Anweisung a1;
…;
Anweisung an;
}else{
Anweisung b1;
…;
Anweisung bm;
}
Grundlagen der Informatik
WS 2006/2007
Seite 162
Bemerkung
•
Die Selektion wählt eine Anweisung bzw. eine Sequenz aus.
•
Besteht der Anweisungsblock nur aus einer einzigen Anweisung, so können
die geschweiften Klammern weggelassen werden.
•
Die Bedingung nach if muss in runden Klammern stehen.
•
Die Bedingung nach if muss vom Typ boolean sein.
•
Der else-Zweig ist optional. Entfällt der else-Zweig, so spricht man von
einer bedingten Anweisung.
Grundlagen der Informatik
WS 2006/2007
Seite 163
Bedingungen in Java können durch Vergleichsoperatoren gebildet werden
Operator
in Java
==
Beispiel
Bedeutung
x == y
x ist gleich y
!=
x != y
x ist ungleich y
>
x > y
x ist größer als y
<
x < y
x ist kleiner als y
>=
x >= y
x ist größer gleich y
<=
x <= y
x ist kleiner gleich y
Grundlagen der Informatik
WS 2006/2007
Seite 164
Bemerkung zu den algebraischen Vergleichsoperatoren
•
Der Operator == darf nicht mit dem Zuweisungsoperator = verwechselt
werden.
•
Alle algebraischen Vergleichsoperatoren können nur zwei Ausdrücke von
primitiven Datentypen vergleichen.
•
Strings sind Objekte und werden mit der Methode equals() verglichen:
String1.equals(String2)
Grundlagen der Informatik
WS 2006/2007
Seite 165
Logische Verknüpfungen von Ausdrücken
Operator
in Java
&&
Bedeutung
||
logisches oder
!
logisches nicht
logisches und
Beispiel
Java
Bedeutung
if (a < b && b < c)
b liegt zwischen a und c
if (b < a || b > c)
b ist kleiner als a oder größer als c
if (!(b < 4))
b ist nicht kleiner als 4
Grundlagen der Informatik
WS 2006/2007
Seite 166
Die Wahrheitstabelle der logischen Verknüpfungen
Operand 1
false
Operand 2
false
logisches und &&
false
false
true
false
true
false
false
true
true
true
Operand 1
Operand 2
logisches oder ||
false
false
false
false
true
true
true
false
true
true
true
true
Operand
logisches nicht !
false
true
true
false
Grundlagen der Informatik
WS 2006/2007
Seite 167
Bemerkung zu den logischen Operatoren
In Java gibt es sowohl für das logische UND als auch für das logische ODER
zwei verschiedene Operatoren.
•
Logische UND: && bzw. &
Wird der Operator & zwischen zwei Operanden verwendet, so wird der
rechte Operand immer ausgewertet, egal ob der linke Operand true oder
false ist.
Wird der Operator && verwendet, so wird der rechte Ausdruck nur dann
ausgewertet, wenn der linke Ausdruck true ist.
Die Operatoren && und & haben identische Wahrheitstabellen.
Grundlagen der Informatik
WS 2006/2007
Seite 168
•
Logische ODER-Operatoren: || bzw. |
Wird der Operator | zwischen zwei Operanden verwendet, so wird der
rechte Operand immer ausgewertet, egal ob der linke Operand true oder
false ist.
Wird der Operator || verwendet, so wird der rechte Ausdruck nur dann
ausgewertet, wenn der linke Ausdruck false ist.
Die Operatoren || und | haben identische Wahrheitstabellen.
•
Prioritäten
! vor && vor ||
Grundlagen der Informatik
WS 2006/2007
Seite 169
// Vergleiche.java
//If Anweisungen und Vergleichsoperatoren
import javax.swing.JOptionPane;
class Vergleiche{
public static void main (String args[]){
String ersteEingabe, zweiteEingabe, ausgabe;
int zahl1, zahl2;
ersteEingabe = JOptionPane.showInputDialog("Geben Sie die
erste ganze Zahl ein");
zweiteEingabe = JOptionPane.showInputDialog("Geben Sie die
zweite ganze Zahl ein");
zahl1 = Integer.parseInt(ersteEingabe);
zahl2 = Integer.parseInt(zweiteEingabe);
//Initialisierung von ausgabe als leerer String:
ausgabe = "";
Grundlagen der Informatik
WS 2006/2007
Seite 170
//Bestimmung des Ausgabestrings
if (zahl1 == zahl2){
ausgabe = ausgabe + zahl1 + " == " + zahl2;
}
if (zahl1 != zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " != " + zahl2;
}
if (zahl1 < zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " < " + zahl2;
}
if (zahl1 > zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " > " + zahl2;
}
if (zahl1 <= zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " <= " + zahl2;
}
Grundlagen der Informatik
WS 2006/2007
Seite 171
if (zahl1 >= zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " >= " + zahl2;
}
if (ersteEingabe.equals(zweiteEingabe)){
ausgabe = ausgabe + "\n" + ersteEingabe + " ist gleich "
+ zweiteEingabe;
}else{
ausgabe += "\n" + ersteEingabe + " ist nicht gleich "
+ zweiteEingabe;
}
JOptionPane.showMessageDialog(null, ausgabe);
System.exit ( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 172
Bemerkung
•
Jede lokale Variable, d.h. eine Variable innerhalb einer Methode muss vor
der Verwendung initialisiert werden. (Im Beispiel ausgabe = "";)
•
Werden lokale Variablen verwendet, bevor sie initialisiert wurden, so erzeugt
der Compiler eine Fehlermeldung
Grundlagen der Informatik
WS 2006/2007
Seite 173
Geschachtelte if- und else- Anweisungen
if- Anweisungen können auch geschachtelt werden.
Ein else-Zweig gehört dabei immer zu dem letzten if, für das noch kein elseZweig existiert.
Beispiel:
if (n < = 5)
if (a > b)
z = a;
else
z = b;
Soll eine andere Zugehörigkeit dargestellt werden, so müssen geschweifte
Klammern gesetzt werden.
Grundlagen der Informatik
WS 2006/2007
Seite 174
Die Selektion: Mehrfache Alternative – else if
else if Anweisungen bieten die Möglichkeit, eine Auswahl unter verschiedenen
Alternativen zu treffen. Die Syntax in Java lautet
if (Bedingung 1)
Anweisung 1; //Block oder Einzelanweisung
else if (Bedingung 2)
Anweisung2;
else if (Bedingung n)
Anweisung n;
else
//der else-Zweig ist optional
Anweisung m;
Grundlagen der Informatik
WS 2006/2007
Seite 175
//Alternative Bestimmung des Ausgabestrings
if ((zahl1 <=
ausgabe =
ausgabe =
ausgabe =
zahl2) &&
ausgabe +
ausgabe +
ausgabe +
(zahl1 != zahl2)){
zahl1 + " < " + zahl2;
"\n" + zahl1 + " <= " + zahl2;
"\n" + zahl1 + " != " + zahl2;
}else if (zahl1 == zahl2){
ausgabe = ausgabe + "\n" + zahl1 + " == " + zahl2;
ausgabe = ausgabe + "\n" + zahl1 + " <= " + zahl2;
ausgabe = ausgabe + "\n" + zahl1 + " >= " + zahl2;
}else {
ausgabe = ausgabe + "\n" + zahl1 + " > " + zahl2;
ausgabe = ausgabe + "\n" + zahl1 + " >= " + zahl2;
ausgabe = ausgabe + "\n" + zahl1 + " != " + zahl2;
}
Grundlagen der Informatik
WS 2006/2007
Seite 176
Ein weiteres Beispiel: Liegt bei einer einzugebenden Jahreszahl ein Schaltjahr vor?
Eine Jahr ist ein Schaltjahr, wenn die Jahreszahl durch 400 teilbar ist oder – falls
nein- wenn sie nicht durch 100 teilbar ist und gleichzeitig aber durch 4 teilbar ist.
import javax.swing.JOptionPane;
class Schaltjahr{
public static void main (String args[]){
String eingabe, ausgabe;
boolean schaltj;
int jzahl;
eingabe = JOptionPane.showInputDialog("Geben Sie ein
Jahr > 1583 ein");
//Konvertierung der Eingabe von String nach int:
jzahl = Integer.parseInt(eingabe);
Grundlagen der Informatik
WS 2006/2007
Seite 177
//Fallunterscheidung
if (jzahl % 400 == 0)
schaltj = true;
else if (jzahl % 100 == 0)
schaltj = false;
else if (jzahl % 4 == 0)
schaltj = true;
else
schaltj = false;
if (schaltj)
ausgabe = eingabe + " ist ein Schaltjahr";
else
ausgabe = eingabe + " ist kein Schaltjahr";
JOptionPane.showMessageDialog(null,ausgabe);
System.exit ( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 178
Die Selektion: Mehrfache Alternative – switch
Die switch-Anweisung dient zur Selektion unter mehreren Alternativen (vgl.
else if-Anweisung).
Die Syntax in Java lautet
switch (Ausdruck){
case
konst1: Anweisungen 1;
break;
case
//ist optional
konst2: Anweisungen 2;
break; //ist optional
……
default : Anweisungen default;
//ist optional
}
Grundlagen der Informatik
WS 2006/2007
Seite 179
Bemerkung zur switch-Anweisung
•
Der Ausdruck nach switch muss vom Datentyp byte, char, short oder
int sein.
•
Nach case muss eine Konstanten stehen, die bereits bei der Übersetzung
des Programms berechnet werden konnte.
•
Nach case darf jeweils nur eine Konstante stehen.
•
Wenn es keine passende Konstante gibt, wird der Programmablauf bei der
default- Anweisung fortgesetzt, falls diese vorhanden ist.
•
Die break-Anweisung ist von der Syntax her nicht erforderlich, sollte aber
stets gesetzt werden.
•
Ohne die break-Anweisung werden nach einer Übereinstimmung alle
weiteren Anweisungen ausgeführt
Grundlagen der Informatik
WS 2006/2007
Seite 180
Beispiel für eine switch Anweisung
Sei monat eine Integer-Variable:
switch (monat){
case 4: tage = 30;
break;
case 6: tage = 30;
break;
case 9: tage = 30;
break;
case 11:tage = 30;
break;
case 2: tage = 28;
break;
default:tage = 31;
}
Grundlagen der Informatik
WS 2006/2007
Seite 181
oder (mit identischem Ergebnis)
switch (monat){
case 4:
case 6:
case 9:
case 11: tage = 30;
break;
case 2: tage = 28;
break;
default: tage = 31;
}
Grundlagen der Informatik
WS 2006/2007
Seite 182
Die Wiederholung oder Schleife
•
Schleifen dienen dazu, eine bestimmte Abfolge von Anweisungen
(Schleifenrumpf) wiederholt auszuführen. Die Anweisungen werden
ausgeführt, so lange eine bestimmte Bedingung (Schleifenbedingung) wahr
ist.
•
Eine Schleife wiederholt eine Anweisung bzw. eine Sequenz.
•
Dabei unterscheidet man Schleifen, bei denen die Schleifenbedingung am
Anfang geprüft wird, und Schleifen, bei denen diese Prüfung am Ende
erfolgt.
Grundlagen der Informatik
WS 2006/2007
Seite 183
Schleifen mit Vorabprüfung (Abweisende Schleifen)
while-Schleife
•
In einer while-Schleife kann eine Anweisung oder ein Anweisungsblock in
Abhängigkeit von der Bewertung der Bedingung wiederholt ausgeführt
werden. Da die Bedingung vor der Ausführung der Anweisungen bewertet
wird, spricht man auch von einer abweisenden Schleife.
•
Die Bedingung wird berechnet und die Anweisungen dann ausgeführt, wenn
der Ausdruck true ist.
•
Danach wird die Berechnung der Bedingung und die eventuelle Ausführung
der Anweisungen wiederholt.
Grundlagen der Informatik
WS 2006/2007
Seite 184
Das Struktogramm für die while-Schleife
while Bedingung
Anweisung 1
Anweisung n
Die Syntax in Java für eine while-Schleife lautet:
while (Bedingung){
Anweisung 1;....;Anweisung n;
}
Grundlagen der Informatik
WS 2006/2007
Seite 185
Bemerkung
•
Besteht der Schleifenrumpf nur aus einer Anweisung, so können die
geschweiften Klammern {} weggelassen werden.
•
Um keine Endlos-Schleife zu erzeugen, muss die Schleifenbedingung durch
eine Anweisung manipuliert werden.
Beispiel
while (i < 10){
.....
i = i + 1;
}
Grundlagen der Informatik
WS 2006/2007
Seite 186
// Durchschnitt.java
/*Berechnet den Durchschnitt von x einzugebenden Zahlen.
Die Anzahl x wird eingelesen
*/
import javax.swing.JOptionPane;
class Durchschnitt{
public static void main (String args[]){
String eingabe, anzahl1, ausgabe;
int anzahl;
double durchschnitt;
int zahl = 0, zaehler = 1, gesamtsumme = 0;
//Einlesen der Anzahl der einzugebenden Zahlen als String:
anzahl1 = JOptionPane.showInputDialog("Geben Sie die Anzahl der
einzugebenden Zahlen ein");
anzahl = Integer.parseInt (anzahl1);
Grundlagen der Informatik
WS 2006/2007
Seite 187
while (zaehler <= anzahl){
eingabe = JOptionPane.showInputDialog("Geben Sie die "
+ zaehler +". Zahl ein");
//Konvertierung der Eingabe von String nach int:
zahl = Integer.parseInt(eingabe);
// Addition der Zahl zur Gesamtsumme
gesamtsumme = gesamtsumme + zahl;
// Zaehler um 1 erhöhen
++zaehler;
}
//Berechnung des Durchschnitts
durchschnitt = (double) gesamtsumme / anzahl;
//Ausgabe
JOptionPane.showMessageDialog(null,
"Durchschnitt:"+durchschnitt);
System.exit ( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 188
Abweisende Schleife mit for
Die Syntax in Java für eine for-Schleife lautet:
for ( Initialisierer ; Bedingung ; Aktualisierung){
Anweisung 1;....;Anweisung n;
}
Beispiel:
for (int i = 1; i <= 10; i++)
System.out.println (i);
Grundlagen der Informatik
WS 2006/2007
Seite 189
Bemerkung zur for-Schleife
•
Die for-Schleife ist eine abweisende Schleife, da zuerst geprüft wird, ob die
Bedingung für ihre Ausführung zutrifft.
•
Zu Beginn der Schleife wird einmalig die Initialisierung durchgeführt.
Hierdurch wird die lokale Variable, die in der Regel als Laufvariable
verwendet wird, definiert und initialisiert. Sie ist nach Beendigung der forSchleife ungültig.
•
Die Schleifenbedingung wird vor dem Durchlaufen des Schleifenrumpfes,
d.h. vor jedem Schleifeneintritt, getestet. Ergibt der Ausdruck false, wird
die Schleife nicht durchlaufen und beendet.
Grundlagen der Informatik
WS 2006/2007
Seite 190
•
Die Aktualisierung, d.h. die Veränderung der Laufvariablen, wird am Ende
jedes Schleifendurchlaufs, aber noch vor dem nächsten Schleifeneintritt
ausgeführt.
•
Die for-Schleife ist eine spezielle Variante der while-Schleife. Sie wird
typischerweise zum Zählen benutzt.
•
Im ersten und letzten Teil einer for-Schleife können Kommata eingesetzt
werden. Damit lassen sich entweder mehrere Variablen deklarieren oder
mehrere Ausdrücke nebeneinander schreiben.
Beispiel:
for (int i = 1, j = 9; i <= j; i++, j--)
System.out.println (i + "*" + j + " = " + i*j);
Grundlagen der Informatik
WS 2006/2007
Seite 191
Zwei Beispiele zur for-Schleife
Beispiel 1
// Addierer.java
/*
Addiert alle ungeraden Zahlen zwischen 1 und 50
*/
class Addierer{
public static void main (String args[]){
int summe = 0;
for (int i = 1; i <= 50; i = i+2){
summe = summe + i;
}
System.out.println (summe);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 192
Beispiel 2
// GeschachtelteSchleife.java
/*
Beispiel für das Schachteln von 2 for-Schleifen
*/
class GeschachtelteSchleife {
public static void main (String
for (int i = 1; i <= 10;
for (int j = 2; j <= 5 ;
System.out.print (i*j
args[]){
i++){
j++)
+ "\t");
System.out.println ();
}
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 193
•
Die for-Schleife ist äquivalent mit
{
Initialisierer;
while (Bedingung){
Anweisung 1;…;Anweisung n;
Aktualisierung;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 194
Die in der Applikation Durchschnitt.java benutzte while-Schleife kann durch
folgende for-Schleife ersetzt werden:
for (int i = 1; i<= anzahl; i++){
eingabe = JOptionPane.showInputDialog("Geben Sie die "
+ i +". Zahl ein");
//Konvertierung der Eingabe von String nach int:
zahl = Integer.parseInt(eingabe);
// Addition der Zahl zur Gesamtsumme
gesamtsumme = gesamtsumme + zahl;
}
Grundlagen der Informatik
WS 2006/2007
Seite 195
Ein weiteres Beispiel für abweisende Schleifen
Die Applikation Ggt.java soll den größten gemeinsamen Teiler von zwei
positiven ganzen Zahlen berechnen. Die beiden Zahlen sollen eingegeben
werden. Falls eine der beiden Zahlen nicht positiv ist, soll eine Fehlermeldung
ausgegeben werden.
Grundlagen der Informatik
WS 2006/2007
Seite 196
// Ggt.java
/*Berechnet den groessten gemeinsamen Teiler von
zwei positiven integer Zahlen
*/
import javax.swing.JOptionPane;
class Ggt{
public static void main (String args[]){
String
ersteEingabe, zweiteEingabe, ausgabe;
int zahl1, zahl2, hilf;
ersteEingabe = JOptionPane.showInputDialog("Geben Sie die
erste positive ganze Zahl ein");
zweiteEingabe =JOptionPane.showInputDialog("Geben Sie die
zweite positive ganze Zahl ein");
zahl1 = Integer.parseInt (ersteEingabe);
zahl2 = Integer.parseInt (zweiteEingabe);
Grundlagen der Informatik
WS 2006/2007
Seite 197
//Sind beide Zahlen positiv?
if (zahl1 <=0 || zahl2 <= 0){
JOptionPane.showMessageDialog(null,"Die Zahlen muessen
positiv sein!","Fehler",JOptionPane.ERROR_MESSAGE);
System.exit (0);
}
while (zahl2 > 0){ //Vertausch zahl1 und zahl2
hilf = zahl1;
zahl1 = zahl2;
zahl2 = hilf;
zahl2 = zahl2 % zahl1;
}
//Ausgabe
JOptionPane.showMessageDialog(null, "ggt von „
+ersteEingabe+" und "+zweiteEingabe+" ist "+zahl1);
System.exit ( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 198
Die Ausgabe der Applikation Ggt.java sieht wie folgt aus:
oder falls eine Zahl nicht echt positiv ist:
Grundlagen der Informatik
WS 2006/2007
Seite 199
Schleife Prüfung am Ende (Annehmende Schleife)
do while-Schleife
Die Syntax in Java lautet
do { Anweisung 1;…;Anweisung n;
} while ( Bedingung);
Struktogramm der do while Schleife:
Anweisung 1
Anweisung n
while Bedingung
Grundlagen der Informatik
WS 2006/2007
Seite 200
Bemerkung zur do while Schleife
•
Die do while-Schleife ist eine annehmende Schleife, da die
Schleifenbedingung erst nach jedem Schleifendurchgang geprüft wird.
•
Bevor es zum ersten Test kommt, ist der Rumpf schon einmal durchlaufen.
•
Achtung: Nach while (Bedingung); muss ein Semikolon gesetzt werden.
Grundlagen der Informatik
WS 2006/2007
Seite 201
//BinaerUmwandler.java
/*
Umwandlung einer ganzen Zahl in eine binäre Zahl
*/
import javax.swing.JOptionPane;
class BinaerUmwandler{
public static void main (String args[]){
String eingabe;
eingabe = JOptionPane.showInputDialog (null,
"Geben Sie eine ganze Zahl ein, die umgewandelt werden soll");
int zahl = Integer.parseInt(eingabe);
//Initialisierung
String binaer = "";
int rest;
Grundlagen der Informatik
WS 2006/2007
Seite 202
do {
rest = zahl % 2;
zahl = zahl / 2;
//Zusammensetzung des Strings zur Binaerdarstellung
binaer = rest + binaer;
} while (zahl > 0);
JOptionPane.showMessageDialog(null,"Die ganze Zahl "+ eingabe
+" hat die binaere Darstellung "+binaer);
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 203
Die Endlosschleifen
Sind die Bedingungen von Schleifen immer wahr, so handelt es sich um
Endlosschleifen.
Beispiele
while-Schleife
while (true)
;
oder
while ( 0 == 0){
// immer wieder und immer wieder
}
Grundlagen der Informatik
WS 2006/2007
Seite 204
Beispiel für eine Endlosschleife mit for
Alle drei Ausdrücke im Kopf der Schleife sind bei einer for Schleife optional.
Damit ist die einfachste Endlosschleife gegeben durch
for (; ; )
;
Die Semikolons sowohl im Schleifenkopf als auch im Schleifenrumpf müssen
stets gesetzt werden.
Beispiel für eine Endlosschleife mit do while
do
;
while (true);
Grundlagen der Informatik
WS 2006/2007
Seite 205
Ausstieg aus Schleifen
• Die Schlüsselwörter break und continue ermöglichen es,
Anweisungsblöcke zu verlassen bzw. wieder einzusteigen.
• Wird innerhalb einer for-, while- oder do/while Schleife eine breakAnweisung gesetzt, so wird der Schleifendurchlauf beendet.
• break beendet immer die innerste Schleife
Beispiel
for (int i = 1; i < 1000;i++){
System.out.println(i);
if (i > 5)
break;
}
Grundlagen der Informatik
WS 2006/2007
Seite 206
Ausstieg aus beliebig tief geschachtelten Schleifen
•
Zum Ausstieg aus beliebig tief geschachtelten Schleifen wird ein so
genanntes Label benutzt, um anzuzeigen, wohin der Sprung gehen soll.
•
Ein Label besteht aus einem Java-Bezeichner, an den ein Doppelpunkt
gehängt wird.
Grundlagen der Informatik
WS 2006/2007
Seite 207
Beispiel für ein Schleifenausstieg mit Label
class BreakMitLabel{
public static void main (String args[]){
TestSchleife:
for (int i = 1; i < 10;i++){
for (int j = 1; j < 10;j++){
System.out.println (i + j);
if ( j > 5)
break TestSchleife;
}
}
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 208
Bemerkung zum Einsatz eines Labels
•
Das Label gibt der Schleife einen Namen (im Beispiel TestSchleife)
•
Die break-Anweisung springt hinter die Schleife, die den Namen des Labels
trägt.
Grundlagen der Informatik
WS 2006/2007
Seite 209
Noch ein Beispiel für ein Schleifenausstieg mit Label
class BreakMitLabel2{
public static void main (String args[]){
TestSchleife:
for (int i = 1; i < 3;i++){
NochEinLabel:
for (int j = 1; j < 10;j++){
System.out.println (i + j);
if ( j > 2)
break NochEinLabel;
}
}
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 210
Das Schlüsselwort continue
Im Gegensatz zu break beendet continue die Schleife nicht, sondern
überspringt die restlichen Anweisungen innerhalb der Schleife, um den
nächsten Durchgang zu starten.
Grundlagen der Informatik
WS 2006/2007
Seite 211
Beispiel für den Einsatz von continue
class BeispielMitContinue{
public static void main (String args[]){
int zahl = 12;
while (zahl > 0){
zahl--;
if (zahl % 3 == 0)
continue;
System.out.println ("zahl = " + zahl);
}
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 212
Die Applikation BeispielMitContinue liefert die Ausgabe
Bemerkung: Die continue-Anweisungen können wie das break mit einem Label
ergänzt werden.
Grundlagen der Informatik
WS 2006/2007
Seite 213
Arrays
•
Ein Array ist ein grundlegende Datenstruktur.
•
Unter einem Array (Feld) versteht man eine Anordnung von Elementen
desselben Datentyps.
•
Ein Array ist ein Objekt.
•
Die einzelnen Elemente heißen Komponenten und können über Indizes
angesprochen werden.
•
In Java beginnen die Indizes eines Arrays stets mit 0.
•
Der Zugriff auf die i-te Komponente des Arrays mit dem Namen arrayName
erfolgt durch arrayName[i-1].
Grundlagen der Informatik
WS 2006/2007
Seite 214
Arrays werden in drei Schritten erstellt
a. Deklaration der Arrayvariablen
b. Zuweisung von Speicher für die Komponenten des Arrays
c.
Initialisierung der Komponenten
zu a.
Durch die Deklaration einer Arrayvariablen wird eine Variable definiert, die auf
ein Array-Objekt zeigen kann. Die Variable ist also eine Speicheradresse, die
zunächst den Wert null (d.h. keinen Wert) hat. Da es sich um einen Zeiger
handelt, bezeichnet man Arrayvariablen als Referenzvariablen.
Grundlagen der Informatik
WS 2006/2007
Seite 215
zu a.
Die allgemeine Form der Definition einer Referenzvariablen auf ein
eindimensionales Array ist:
Typname[] arrayName;
oder
Typname arrayName [];
Grundlagen der Informatik
WS 2006/2007
Seite 216
zu b:
Mit dem new-Operator kann das konkrete Array erzeugt werden.
Beispiel:
arrayName = new byte [4] legt ein Array-Objekt mit 4 Komponenten an.
Diese Komponenten werden mit dem default-Wert binär 0 belegt (d.h. z.B. bei
Zahlen wie int mit Wert 0, boolean mit false, char mit null und Objekte
mit null).
Es wird jetzt 4 mal so viel Speicher reserviert, wie der Datentyp des Arrays für
die Speicherung von einem Element benötigt.
zu c:
Durch Zuweisung von Werten an die Komponenten können die Default-Werte
mit sinnvollen Werten überschrieben werden, z.B. arrayName[0] = 3;
Grundlagen der Informatik
WS 2006/2007
Seite 217
zu a,b,c: Implizites Erzeugen über eine Initialisierungsliste
Eine andere Möglichkeit, ein Array anzulegen, ist, das Array implizit über eine
Initialisierungsliste zu erzeugen und gleichzeitig zu initialisieren.
Beispiel: byte[] arrayName = {1,2,3,4}
Das Erzeugen des Array-Objektes wird hier vom Compiler im Verborgenen
durchgeführt. Die Definition der Referenzvariablen arrayName, das Anlegen
des Arrays, sowie die Initialisierung der Array-Elemente erfolgt in einem Schritt.
Grundlagen der Informatik
WS 2006/2007
Seite 218
Beispiele für das Erzeugen von Arrays
/* a
/* b
/* c
*/
*/
*/
int feld[];
feld = new int [8];
for (int i = 0; i < feld.length; i++)
feld[i] = i*i;
oder
/* a
*/
/* b,c */
int feld[];
feld = new int[] {0,1,4,9,16,25,36,49};
oder
/* a,b,c
*/
int feld[] = {0,1,4,9,16,25,36,49};
Grundlagen der Informatik
WS 2006/2007
Seite 219
// TemperaturJan.java
//Initialisierung und Ausgabe eines Arrays
class TemperaturJan{
public static void main (String args[]){
final int ANZAHL_TAGE = 31;
String ausgabe;
double temperatur[] = new double [ANZAHL_TAGE];
//Initialisierung mit Durchschnittswerten;
for (int i = 0; i < temperatur.length;i++)
temperatur [i] = 5.3;
//Ausgabe der Arraywerte
ausgabe = "Tag\tTemperatur\n";
for (int i = 0; i < temperatur.length;i++)
ausgabe += i+ "\t" + temperatur [i] + "\n";
System.out.println (ausgabe);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 220
Bemerkung zu Arrays
•
Arrays kann man von einem beliebigen Datentyp oder einer beliebigen
Klasse erstellen. Dies können primitive Datentypen, Objekte oder andere
Arrays sein. Im letzteren Fall spricht man dann von mehrdimensionalen
Arrays.
•
Die Größe eines Arrays wird zum Zeitpunkt der Erstellung des Arrays
festgelegt, danach kann sie nicht mehr verändert werden.
•
Mit Hilfe der Eigenschaft length kann man die Anzahl der Komponenten
des Arrays erhalten. (siehe temperatur.length im Programm-Beispiel)
•
Java erlaubt einen Zugriff ausschließlich auf solche Elemente eines Arrays,
die auch tatsächlich vorhanden sind. Bei jedem Zugriff auf ein Array wird
der angegebene Index mit den in der Array-Deklaration angegebenen
Grenzen verglichen.
Grundlagen der Informatik
WS 2006/2007
Seite 221
Konstanten in Java
•
Das Schlüsselwort final (siehe Beispiel TemperaturJan) indiziert, dass
die deklarierte Variable (ANZAHL_TAGE) eine Konstante ist. Sie wird bei
ihrer Deklaration initialisiert und kann danach nicht wieder verändert werden.
•
Manchmal werden Konstanten auch als „read-only“ Variablen bezeichnet.
•
Der Versuch, eine final-Variable zu verändern, resultiert in einer
Fehlermeldung des Compilers.
•
Konstanten werden durchgängig in Großbuchstaben geschrieben.
Unterstriche sind hier erlaubt.
Grundlagen der Informatik
WS 2006/2007
Seite 222
Methoden
Eine Methode ist ein Block von Anweisungen, der gewisse Eingabeparameter
als Input benötigt und nach Ausführungen der Anweisungen einen Wert zurück
gibt. Dabei kann die Menge der Eingabeparameter oder die Rückgabe auch leer
sein.
Eine Methode besteht aus vier Teilen (ein Konstruktor nur aus drei, s. später):
Dem Rückgabetyp, dem Methodennamen, der Eingabe- oder Parameterliste
und dem Methodenrumpf.
Der Rückgabetyp gibt den Datentyp des zurückgegebenen Wertes an.
Der Methodenname legt den Namen der Methoden fest.
Der Methodenrumpf besteht aus einzelnen Anweisungen, die von
geschweiften Klammern { } umschlossen werden, d.h. einen Block bilden.
Grundlagen der Informatik
WS 2006/2007
Seite 223
Damit hat eine Methode folgende Gestalt
Rückgabetyp methodenName (Parameterliste){
Anweisung 1;
……. ;
Anweisung m;
Methodenrumpf
}
Grundlagen der Informatik
WS 2006/2007
Seite 224
Die Eigenschaften der Parameterliste
•
Sie besteht aus endlich vielen Parametern, die von runden Klammern
umschlossen werden.
•
Die Parameterliste kann auch leer sein. Man muss dennoch die runden
Klammern hinter dem Methodennamen setzen, d.h. methodenName()
•
Parameter können beliebige Daten sein (z.B. Zahlenwert, Strings, Objekte).
Parameter werden wie Variablen definiert, d.h. erst der Datentyp, dann der
Name.
Jeder Parameter muss einzeln definiert werden, die Parameter werden
durch Kommata getrennt.
•
Wichtig: Die Reihenfolge der Parameter in der Methodendeklaration ist
bindend festgelegt.
Grundlagen der Informatik
WS 2006/2007
Seite 225
Methodendeklaration – der Rückgabetyp
Man unterscheidet zwei Arten von Methoden: Methoden ohne Rückgabewert
und Methoden mit Rückgabewert.
Wie Variablen müssen Methoden auch deklariert werden:
Die Syntax einer Methode mit Rückgabe
Datentyp des Rückgabewertes methodenName (Datentyp p1,…,Datentyp pn){
…….;
return Rückgabewert;
}
Grundlagen der Informatik
WS 2006/2007
Seite 226
Methode ohne Rückgabe
void methodenName (Datentyp p1,…,Datentyp pn){
…….;
}
•
Das reservierte Wort void gibt an, dass die Methode keinen
Rückgabewert liefert.
Grundlagen der Informatik
WS 2006/2007
Seite 227
Bekannte Beispiele für Methoden
•
Methode showMessageDialog() der Klasse JOptionPane liefert void
•
Methode showInputDialog() der Klasse JOptionPane liefert String
•
Methode parseInt() der Klasse Integer liefert int
•
Methode main()liefert void
Grundlagen der Informatik
WS 2006/2007
Seite 228
Anmerkungen zu Methoden
•
Methoden müssen stets vollständig in der Klasse angegeben werden, der sie
angehören.
•
Es gibt keine Methoden außerhalb von Klassen.
Grundlagen der Informatik
WS 2006/2007
Seite 229
Der Aufruf einer Methode
Der Aufruf erfolgt durch die Angabe des Namens der Methode mit Angaben der
Eingabeparameter.
Beispiele:
Integer.parseInt (ersteEingabe);
JOptionPane.showMessageDialog(null,"Die Zahlen muessen
positiv sein!","Fehler",JOptionPane.ERROR_MESSAGE);
Grundlagen der Informatik
WS 2006/2007
Seite 230
Statische Methoden
Es werden zwei Arten von Methoden unterschieden. Dies sind die
Instanzmethoden und die Klassenmethoden. Hier beschäftigen wir uns zunächst
mit den Klassenmethoden.
Klassenmethoden oder statische Methoden sind eine spezielle Art von
Methoden, die kein Objekt benötigen (die Bedeutung von Objekte werden wir
später behandeln).
Eine statische Methode wird unter Angabe des Namens derjenigen Klasse, in
der sie deklariert ist, aufgerufen, d.h.
Klassenname.Methodenname (…);
Der Klassenname kann auch weggelassen werden, wenn die Methode in
derselben Klasse deklariert ist.
Grundlagen der Informatik
WS 2006/2007
Seite 231
Deklaration von statischen Methoden
Deklariert wird eine statische Methode, indem man vor dem Rückgabetyp das
reservierte Wort static schreibt.
Statische Methode mit und ohne Rückgabe
static Datentyp des Rückgabewertes methodenName (Datentyp p1,…,Datentyp pn){
…….;
return Rückgabewert;
}
static void methodenName (Datentyp p1,…,Datentyp pn){
…….;
}
Grundlagen der Informatik
WS 2006/2007
Seite 232
Beispiele für den Einsatz von statischen Methoden
class MaximumBestimmung {
static int maximum (int x, int y){
if (x > y)
return x;
else
return y;
}
public static void main (String args[]) {
int a = 3, b = 10;
int m;
m = maximum(a,b);
System.out.println("Maximum ist "+m);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 233
Ein weiters Beispiel für die Verwendung von Klassenmethoden
// Rechteck.java
/*Liest die Seitenlaengen eines Rechtecks ein und ermittelt
Flaecheninhalt und Laenge der Diagonale
*/
import javax.swing.JOptionPane;
class Rechteck {
static double liesSeite() {
String eingabe;
double zahl;
eingabe =JOptionPane.showInputDialog("Geben Sie eine
Seitenlaenge des Rechtecks ein:");
zahl = Double.parseDouble (eingabe);
return zahl;
}
Grundlagen der Informatik
WS 2006/2007
Seite 234
static double inhalt (double x, double y){
double i;
i = x*y;
return i;
}
static double diagonale (double x, double y){
double d;
d = Math.sqrt(x*x + y*y);
return d;
}
public static void main (String args[]) {
double a, b, c , d;
a = liesSeite();
b = liesSeite();
c = diagonale(a,b);
d= inhalt(a,b);
String ausgabe = "Flaecheninhalt: " + d +"\nDiagonale: "+c;
JOptionPane.showMessageDialog(null,ausgabe);
System.exit (0);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 235
Bemerkung: Die Deklaration static
Nicht nur Methoden können static sein.
Sollen Attribute oder Methoden für alle Objekte der Klasse zugänglich sein,
so werden sie als static deklariert. Man spricht dann von Klassenvariablen
bzw. Klassenmethoden.
Meist werden Methoden als static deklariert, um sie anderen Klassen zur
Verfügung zu stellen, ohne Objekte der betreffenden Klassen zu erzeugen,
z.B. Methode sqrt() aus der Klasse Math.
Grundlagen der Informatik
WS 2006/2007
Seite 236
Methoden der Klasse Math
•
Für die arithmetischen und trigonometrischen Standardfunktionen hat Java
eine spezielle Klasse, die Klasse Math.
• Math gehört zum Paket java.lang, dem einzigen Paket, das
automatische in jedes Programm importiert wird.
• Math-Methoden können damit jederzeit genutzt werden.
•
Alle Math-Methoden sind static.
Grundlagen der Informatik
WS 2006/2007
Seite 237
Einige Methoden der Klasse Math
• abs: Liefert den Betrag einer Zahl
double abs (double a)
float abs (float a)
int abs (int a)
long abs (long a)
• acos, asin, atan: Liefert den arc cosinus, arc sinus, arc tan eines Winkels
double acos (double a)
double asin (double a)
double atan (double a)
Grundlagen der Informatik
WS 2006/2007
Seite 238
• cos, sin, tan: Trigonometrische Funktionen, in Bogenmaß
double cos (double a)
double sin(double a)
double tan(double a)
• exp: Liefert die Eulersche Zahl e hoch einen double Wert
double exp (double a)
• log: Liefert den natürlichen Logarithmus (d.h. zur Basis e) von einem
double-Wert
double log (double a)
Grundlagen der Informatik
WS 2006/2007
Seite 239
• max, min: Liefert Maximum bzw. Minimum zweier Zahlen
double max (double a, double b)
float max(float a, float b)
int max(int a, int b)
long max (long a, long b)
double min (double a, double b)
float min(float a, float b)
int min(int a, int b)
long min (long a, long b)
Grundlagen der Informatik
WS 2006/2007
Seite 240
• pow: Liefert den Wert des ersten Arguments potenziert mit dem zweiten
Argument
double pow (double a, double b)
• random: Liefert einen positiven Zufalls- double-Wert größer gleich 0.0 und
kleiner 1.0
double random()
• round: Runden auf ganze Zahlen
long round (double a)
int round (float a)
• sqrt: Liefert die Wurzel
double sqrt (double a)
Grundlagen der Informatik
WS 2006/2007
Seite 241
Runden von Zahlen
•
Die Methode round() der Klasse Math rundet Zahlen.
• round() rundet auf die nächste Ganzzahl vom Typ long (kaufmännisches
Runden).
Beispiel: double a = 97.56; // ergibt Math.round(a) = 98;
•
Mit Hilfe von round() können auch Zahlen auf Nachkomma-Stellen gerundet
werden.
•
Beispiel: Runden auf 2 Nachkommastellen
Math.round(a*100)/100. liefert für a = 1.3456 den Wert 1.35
Grundlagen der Informatik
WS 2006/2007
Seite 242
Überladen von Methoden
Eine Methode ist gekennzeichnet durch Rückgabewert, Name und Parameterliste.
Eine überladene Methode ist eine Methode mit gleichem Namen wie eine andere
Methode, aber eine davon verschiedenen Parameterliste. Es gibt zwei Arten:
•
Eine Methode kann die gleiche Anzahl von Parametern wie eine andere
besitzen und unterschiedliche, aber für den Compiler unterscheidbare, Typen
annehmen
•
Die Anzahl der Parameter kann unterschiedlich sein.
Beispiel die Methode min() aus der Klasse Math.
Grundlagen der Informatik
WS 2006/2007
Seite 243
Grundlagen der Objektorientierung
Ziel der objektorientierten Programmierung (OOP) ist die mehrfache Verwendung
von Programmcode.
Die Grundidee der OOP ist der Ansatz, dass Programme die Welt oder Teile der
Welt abbilden.
Die Welt besteht aus Objekten. Das sind
•
Gegenstände (Autos, Flugzeuge, Schiffe…)
•
Lebewesen (Menschen, Tiere, Pflanzen…)
•
abstrakte Konstrukte (Staaten, Konzerne, Konten…)
Grundlagen der Informatik
WS 2006/2007
Seite 244
Für diese Objekte gilt
•
Sie können in Kategorien bzw. Klassen -d.h. in sinnvolle Einheitenzusammengefasst werden.
Beispiel: Tiere, Pflanzen, Wirbeltiere, Säugetiere, Fische gehören alle zur
Klasse der Lebewesen.
•
Jedes Objekt hat individuelle Eigenschaften (ein Objekt „Person“ hat einen
Namen, ein Objekt „Auto“ eine Marke…)
•
Objekte erfahren Prozesse oder führen sie selber aus (ein Mensch wird
geboren, der Kontostand von Person A verringert sich…)
Grundlagen der Informatik
WS 2006/2007
Seite 245
Die Theorie der Objektorientierung fasst dies zu einem Konzept zusammen.
In der Objektorientierung werden die folgende Bezeichnungen verwendet:
→
Klassen
Eigenschaften →
Attribute
Kategorien
Prozesse
→
Methoden
Klasse
attribute
methoden()
Grundlagen der Informatik
WS 2006/2007
Seite 246
Klassen und Objekte
•
Eine Klasse ist ein Schema, eine Schablone, eine Kategorie, in die
bestimmte individuelle Objekte eingeordnet werden können.
•
Gehört ein Objekt zu einer Klasse, gelten alle Eigenschaften der Klasse.
•
Ein Objekt ist immer eine konkrete Ausprägung einer Klasse, man sagt:
•
•
Ein Objekt ist eine Instanz seiner Klasse.
Die Klasse ist der zentrale Begriff aus Sicht der objektorientierten
Programmierung.
•
Ein Objekt ist eindeutig bestimmt durch seine Attribute (Daten,
Eigenschaften) und durch seine Methoden (Funktionen, Verhalten).
Grundlagen der Informatik
WS 2006/2007
Seite 247
•
Wie man von einem Konstruktionsplan für ein Auto mehrere Fahrzeuge von
diesem Typ bauen kann, so kann man auch von einer Klasse mehrere
Objekte „bauen“.
•
So wie die Autos in unterschiedlichen Farben, Motoren und Ausstattungen
gebaut werden, so können auch von Klassen die Objekte mit verschiedenen
Eigenschaften erstellt werden.
•
Aus der Weltanschauung könnte dann der Hersteller dem Paket, die
Werksabteilung der Klasse, die Materialien den Attributen, die Maschinen
den Methoden und der Konstruktionsplan dem Konstruktor in Java
entsprechen.
Grundlagen der Informatik
WS 2006/2007
Seite 248
•
Eine einfache Anwendung für eine Klasse ist das Zusammenfassen
zusammengehöriger Variablen.
String ist eine Klasse, die aus einem Array aus char-Variablen besteht.
Nach der Erzeugung des Strings, d.h. nach dem Anlegen der Instanz bzw.
des Objektes, besteht der String aus zusammengehörigen Buchstaben, die
zu einem Wort zusammengefasst sind.
Grundlagen der Informatik
WS 2006/2007
Seite 249
Kapselung
Ein wesentliches Konzept der Objektorientierung ist, dass die Attribute von den
Methoden vor der Außenwelt gekapselt sind. Sie können (im allgemeinen) nur
durch die Methoden verändert werden.
Die Methoden eines Objektes sind die Schnittstellen des Objektes zur
Außenwelt.
Es bedeutet, dass die internen Strukturen von Objekten vor dem Verwender
verborgen sind.
Attribute
Grundlagen der Informatik
WS 2006/2007
Seite 250
Generalisierung und Vererbung
•
Einzelne Klassen können zu weiteren Klassen zusammengefasst werden.
Z.B. können die Klasse der Autos, die Klasse der Flugzeuge, die Klasse der
Schiffe zur Klasse der Fortbewegungsmittel zusammengefasst werden.
Man sagt, dass die einzelnen Klassen generalisiert bzw. verallgemeinert
werden.
•
Die allgemeine Klasse heißt Superklasse, Oberklasse oder Mutterklasse.
•
Die speziellen Klassen heißen Subklassen, Unterklassen oder Kindklassen.
•
Eine Superklasse hat eine besondere Beziehung zu ihrer Subklasse (oder
ihren Subklassen), eine „Ist-ein“-Beziehung (‚is-a‘ relation)
Grundlagen der Informatik
WS 2006/2007
Seite 251
•
Alle Attribute und Methoden der Superklasse sind gleichzeitig Attribute und
Methoden jeder ihrer Subklassen.
•
Man sagt, dass ein Objekt einer Subklasse die Attribute und Methoden der
Superklasse erbt. Die Attribut und Methoden sind dann für die Subklasse
sichtbar.
•
Dieses Prinzip nennt man Vererbung.
•
Für Subklassen spezifische Attribute und Methoden können nicht geerbt
werden.
Grundlagen der Informatik
WS 2006/2007
Seite 252
UML
•
UML (Unified Modelling Language) ist eine Sprache zur visuellen
Modellierung von Strukturen und Prozessen von Software.
•
Sie ist Standard der modernen Software-Entwicklung
•
Eines der Diagramme der UML ist das Klassendiagramm
•
Jede Klasse wird als ein Rechteck dargestellt, mit dem Namen der Klasse
im oberen Teil, allen Daten (Attributen) im mittleren Teil und den Methoden
im unteren Teil.
•
Oft wird in der UML einer der beiden unteren Teile weggelassen, wenn sie
für die jeweilige Betrachtung nicht interessant sind.
Grundlagen der Informatik
WS 2006/2007
Seite 253
Einige Darstellungsformen aus UML
Klasse
Objekt
Klasse
:Klasse
attribute
attribute
methoden()
methoden()
Vererbung
SubKlasse
SuperKlasse
Grundlagen der Informatik
WS 2006/2007
Seite 254
Ein erstes Beispiel für eine Klasse
Gegeben sei ein Punkt im Koordinatensystem mit einer x- und einer yKoordinate.
Damit hat ein jeder Punkt die Eigenschaften (Attribute)
double y; double x
Jeder Punkt hat auch Methoden, dies sind Methoden, die die Koordinaten x
und y setzen und Methoden, die die Koordinaten eines Punktes auslesen.
Natürlich sind auch noch andere Methoden möglich.
Damit hat die Klasse Punkt die Form
Grundlagen der Informatik
WS 2006/2007
Seite 255
Die Syntax für eine Klasse lautet
class Klassenname{
Deklaration der Attribute;
Deklaration der Methoden;
}
Grundlagen der Informatik
WS 2006/2007
Seite 256
class Punkt {
double x;
double y;
double getX(){
return x;
}
//Attribut
//Attribut
//get-Methode
double getY(){
return y;
}
//get-Methode
void setX(double i){
x = i;
}
//set-Methode
void setY(double j){
y = j;
}
//set-Methode
}
Grundlagen der Informatik
WS 2006/2007
Seite 257
Erzeugen eines Objektes, d.h. einer Instanz einer Klasse
Als nächstes wird ein Objekt von der Klasse Punkt erzeugt.
Dies erfolgt in innerhalb der Klasse PunktApp in der main-Methode.
class PunktApp{
public static void main (String args[]) {
Punkt p;
//Deklaration der Variable
p = new Punkt(); //Erzeugung des Objektes
p.setX(3.7);
p.setY(4.0);
System.out.println("Koordinaten des
Punktes sind:
("+p.getX() +","+ p.getY()+")");
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 258
Der new-Operator
•
Die Erzeugung eines Objektes geschieht mit dem new-Operator und der
Zuordnung der Variablen:
KlassenName variable = new KlassenName();
(*)
•
Der new-Operator erzeugt bzw. instanziiert ein Objekt.
•
Nach dem new-Operator erscheint eine spezielle Methode, der so genannte
Konstruktor. Er trägt den Namen der Klasse des erzeugten Objekts und
initialisiert die Attribute.
Dem Konstruktor können Parameter übergeben werden –oder wie hierkann die Parameterliste leer sein. In diesem Fall spricht man von einem
Standardkonstruktor.
Grundlagen der Informatik
WS 2006/2007
Seite 259
•
Die Zeile (*) kann auch in zwei Zeilen geschrieben werden:
Deklaration der variable durch Klassenname variable;
hierdurch wird Speicherplatz reserviert.
Erzeugung des Objektes mit dem new-Operator, d.h.
variable = new KlassenName();
Grundlagen der Informatik
WS 2006/2007
Seite 260
Zugriff auf die Methoden und Attribute des Objektes
•
Wurde ein Objekt p erzeugt, so kann durch p.Attribut auf die Attribute
zugegriffen bzw. durch p.methode() die Methoden des Objektes verwendet
werden. Im Beispiel PunktApp wurde z.B. durch p.setX(3.7); die
Methode setX() des Objektes p aufgerufen.
•
Bemerkung: Im Allgemeinen ist es nicht erlaubt, direkt auf Attribute
zuzugreifen. Auch der Zugriff auf Methoden kann beschränkt sein. Dies wird
näher im Kapitel: „Öffentlichkeit und Privatsphäre“ behandelt.
Grundlagen der Informatik
WS 2006/2007
Seite 261
Lokale Variablen und Attribute
•
Ein Aufrufparameter einer Methode hat einen Geltungsbereich nur für die
eine Methode, die mit ihm aufgerufen wird.
•
Er ist eine lokale Variable. Lokale Variablen gelten („leben“) immer nur in der
Methode, in der sie deklariert sind.
•
Attribute sind keine lokalen Variablen. Sie sind Variablen, die in der
gesamten Klasse bekannt sind. Sie gelten damit auch in jeder Methode, die
in der Klasse deklariert ist.
Grundlagen der Informatik
WS 2006/2007
Seite 262
Ein weiteres Beispiel:
Es sollen zwei Konten erstellt werden, von denen jeweils ein Betrag zugebucht
und abgebucht werden kann.
class Konto{
//Attribute
int kontoNr;
double saldo;
//Methoden
void einzahlen (double betrag){
saldo += betrag;
}
void abheben (double betrag){
saldo -= betrag;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 263
Die Erzeugung der Objekte findet in der main()-Methode der Klasse KontoApp
statt.
class KontoApp{
public static void main (String args[]) {
Konto k1, k2;
k1 = new Konto();
k2 = new Konto();
k1.kontoNr = 1;
k2.kontoNr = 2;
k1.saldo = 1000;
k2.saldo = 500;
k1.einzahlen(300);
k2.abheben(40);
System.out.println("Saldo von Konto "
+k1.kontoNr
+": "+k1.saldo
+"\nSaldo von Konto "
+k2.kontoNr +": "+k2.saldo);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 264
Bemerkung zu der Klasse Konto
•
In der Applikation KontoApp wurden zwei Instanzen der Klasse Konto
erstellt.
•
Von KontoApp, d.h. außerhalb der Klasse Konto, konnte direkt auf die
Attribute der Objekte zugegriffen werden und diese verändert werden z.B.
durch k1.saldo = 1000;
•
Dies ist sehr gefährlich, denn somit können unkontrolliert Werte von
Attributen von außen manipuliert werden, ohne dass das Objekt, d.h. der
Besitzer der Attribute, hierauf Einfluss hat.
•
Um dies zu verhindern, sollten Attribute stets geschützt werden.
Grundlagen der Informatik
WS 2006/2007
Seite 265
Öffentlichkeit und Privatsphäre
•
Oft ist es sinnvoll Attribute und Methoden einer Klasse nur teilweise oder
gar nicht der Öffentlichkeit zur Verfügung zu stellen.
•
Man spricht von Kapselung, wenn die Attribute vor der Außenwelt
verborgen sind und nur über die eigenen Methoden verändert werden
können.
•
Die Kapselung ist eines der wichtigsten Konzepte der Objektorientierung.
•
Somit kann kein anderes Programm oder Objekt auf verborgene Attribute
zugreifen und dort unbeabsichtigt Effekte bewirken.
•
Auch wird dadurch verhindert, dass das Objekt unbeabsichtigt in anderen
Programmen etwas zerstört.
Grundlagen der Informatik
WS 2006/2007
Seite 266
Sichtbarkeit
In einer Klasse kann bei einer Definition jeder einzelnen Komponente separat
spezifiziert werden, in welcher Weise der Zugriff auf diese Komponente
möglich ist. Unterschieden werden kann zwischen private, protected,
public und keine Angabe.
Spezifizierer in selber
Klasse
in Unterklasse in selbem
Paket
private
sichtbar
nichts
angegeben
sichtbar
protected
sichtbar
sichtbar
sichtbar
public
sichtbar
sichtbar
sichtbar
überall
sichtbar
sichtbar
Grundlagen der Informatik
WS 2006/2007
Seite 267
In Java sind Zugriffsmodifikatoren erlaubt für Klassen, Schnittstellen,
Methoden, Konstruktoren und Attribute.
Die nächste Tabelle zeigt die möglichen Zugriffsmodifikatoren
Element
private
nichts
angegeben
protected
public
Attribut
X
X
X
X
Methode
X
X
X
X
Konstruktor
X
X
X
X
Klasse
X
X
Schnittstelle
X
X
Grundlagen der Informatik
WS 2006/2007
Seite 268
Wenn wir in der Klasse Konto.java das Attribut kontoNr und saldo
mit private schützen, so kann die Applikation KontoApp nicht mehr
hierauf zugreifen.
class Konto{
//Attribute
private int kontoNr;
private double saldo;
//Methoden
void einzahlen (double betrag){
saldo += betrag;
}
void abheben (double betrag){
saldo -= betrag;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 269
Es müssen Methoden definiert werden, die den Zugriff auf die Attribute ermöglichen:
class Konto{
private int kontoNr;
private double saldo;
public int getKontoNr () {
return kontoNr;
}
public double getSaldo () {
return saldo;
}
void setKontoNr ( int nummer) {
kontoNr = nummer;
}
void setSaldo ( double kontoStand) {
saldo = kontoStand;
}
//weitere Methoden einzahlen() und abheben()
}
Seite 270
Grundlagen der Informatik
WS 2006/2007
public class KontoApp{
public static void main (String args[]) {
Konto k1, k2;
k1 = new Konto();
k2 = new Konto();
k1.setKontoNr(1);
k2.setKontoNr(2);
k1.setSaldo(1000);
k2.setSaldo(500);
k1.einzahlen(300);
k2.abheben(40);
System.out.println("Saldo von Konto "+k1.getKontoNr() +":"
+k1.getSaldo()
+"\nSaldo von Konto "
+k2.getKontoNr() +": "
+k2.getSaldo());
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 271
Die Applikation erzeugt
kontoNr und saldo von k1 und k2 können also kontrolliert durch die
eigenen Methoden verändert werden.
Grundlagen der Informatik
WS 2006/2007
Seite 272
Das Beispiel Konto wird nun etwas erweitert
Es soll eine Applikation programmiert werden, die 5 Konten mit einem
Startguthaben von 100 Euro einrichtet und Überweisungen von einem Konto zu
einem anderen Konto durchführt.
Grundlagen der Informatik
WS 2006/2007
Seite 273
public class Konto{
//Attribute
private int kontoNr;
private double saldo;
//Konstruktor
public Konto(int kontoNr){
this.kontoNr = kontoNr;
saldo = 100; //Startguthaben
}
//Methoden
public int getKontoNr(){
return kontoNr;
}
Grundlagen der Informatik
WS 2006/2007
Seite 274
public double getSaldo(){
return saldo;
}
public void einzahlen (double betrag){
saldo += betrag;
}
public void abheben (double betrag){
saldo -= betrag;
}
public void ueberweisen(Konto nachKonto, double betrag){
saldo -= betrag;
nachKonto.einzahlen(betrag);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 275
//Applikation, die Konten erzeugt und Überweisungen ermöglicht
import javax.swing.JOptionPane;
class KontoApp{
public static void main (String args[]) {
final int ANZAHL_KONTEN = 5;
//erzeugt Array von Konten mit Kontonummer 0,1,2,3,4
Konto kontoArray[] = new Konto[ANZAHL_KONTEN];
for (int i = 0; i< kontoArray.length;i++){
kontoArray[i] = new Konto(i);
}
Konto vonKonto, nachKonto;
double betrag;
String eingabe, ausgabe;
Grundlagen der Informatik
WS 2006/2007
Seite 276
eingabe =JOptionPane.showInputDialog("Überweisung von
Kontonr.");
vonKonto = kontoArray[Integer.parseInt(eingabe)];
eingabe = JOptionPane.showInputDialog("...nach Kontonr.");
nachKonto = kontoArray[Integer.parseInt(eingabe)];
eingabe = JOptionPane.showInputDialog("Betrag:");
betrag = Double.parseDouble(eingabe);
//Überweisung durchführen:
vonKonto.ueberweisen(nachKonto, betrag);
//Ausgabe:
ausgabe = "Kontostand von Kontonr." + vonKonto.getKontoNr();
ausgabe += ": " + vonKonto.getSaldo() + " Euro \n";
ausgabe += "Kontostand von Kontonr."+ nachKonto.getKontoNr();
ausgabe += ": " + nachKonto.getSaldo() +" Euro";
JOptionPane.showMessageDialog(null,ausgabe);
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 277
Die Deklaration eines Konstruktors
•
Konstruktoren sind Methoden zur Initialisierung von Objektattributen.
•
Sie heißen genau wie die Klasse.
•
Im Unterschied zu anderen Methoden wird bei ihnen kein Rückgabewert
deklariert.
•
Konstruktoren werden bei der Objekterzeugung mit dem new-Operator
aufgerufen.
•
Ein Konstruktor hat allgemein die Syntax:
KlassenName (Datentyp p1,…,Datentyp pn){
Anweisungen;
}
Grundlagen der Informatik
WS 2006/2007
Seite 278
Bemerkung zum Standardkonstruktor
•
Stellt der Compiler fest, dass kein Konstruktor definiert wurde, so baut der
automatisch selbst einen.
•
Diesen nennt man Standardkonstruktor.
•
Der Standardkonstruktor ist immer parameterlos.
Grundlagen der Informatik
WS 2006/2007
Seite 279
Das Schlüsselwort this
•
Der Bezeichner this dient dazu, auf das Objekt selbst zu verweisen
•
Auf eine eigene Methode oder ein eigenes Attribut kann man verweisen mit
der Syntax this.methode() bzw. this.attribut
•
Solange die Attributnamen nicht mehrdeutig sind, braucht this nicht
benutzt zu werden.
• this muss verwendet werden, wenn es Namenskonflikte mit gleichnamigen
lokalen Variablen gibt (s. kontoNr ist einmal das Attribut von Konto, und
einmal der Name des Eingabeparameters des Konstruktors).
•
Bemerkung: Namenskonflikte könnten natürlich auch vermieden werden,
indem man der lokalen Variable einen anderen Namen gibt. In der Praxis
wird aber gerade bei Konstruktormethoden hiervon Abstand genommen.
Grundlagen der Informatik
WS 2006/2007
Seite 280
Noch ein Beispiel für das Arbeiten mit Objekten
Problembeschreibung: Ein Computerprogramm soll die Laufzeiten der
Teilnehmer eines Rennens ermittelt. Eingegeben werden Startzeit und
Ankunftszeit eines Läufers.
Version 1.0: Zunächst sollen die Zeiten in vollen Stunden angegeben werden.
Wir entwickeln die Software mit Hilfe der drei Phasen:
Analyse: Anforderungen an die Software ermitteln und beschreiben
(Verwendung von Klassendiagrammen)
Entwurf: Aufbauend auf der Analyse, die Softwarearchitektur und die
Spezifikation der Komponenten erstellen (insb. Algorithmen der Methoden)
Implementierung: Codierung der Klassen und Programme
Grundlagen der Informatik
WS 2006/2007
Seite 281
/*
Die Klasse ermöglicht die Berechnung die Gesamtlaufzeit eines Läufers
*/
class Laeufer{
//Attribute
private int startZeit, ankunftsZeit, laufDauer;
//Konstruktor:
Laeufer(int startZeit, int ankunftsZeit){
this.startZeit = startZeit;
this.ankunftsZeit = ankunftsZeit;
}
int getLaufDauer (){
laufDauer = ankunftsZeit - startZeit;
return laufDauer;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 282
Die zugehörige Applikation des Beispiels
import javax.swing.JOptionPane;
class LaufZeitApp{
public static void main (String args[]){
String ersteEingabe, zweiteEingabe, ausgabe;
int start, ankunft, dauer;
//Einlesen der Eingabestrings:
ersteEingabe = JOptionPane.showInputDialog ("Gib die
Startzeit des Läufers ein:");
zweiteEingabe = JOptionPane.showInputDialog ("Gib die
Ankunftzeit ein:");
//Konvertierung String in int:
start = Integer.parseInt(ersteEingabe);
ankunft = Integer.parseInt(zweiteEingabe);
Grundlagen der Informatik
WS 2006/2007
Seite 283
//Erzeugung eines speziellen Läufers mit start,ankunft-Zeit
Laeufer teilnehmer = new Laeufer(start,ankunft);
//Berechnung Laufdauer
dauer = teilnehmer.getLaufDauer();
//Erzeugung Ausgabestring
ausgabe = "Die Laufzeit betraegt " +dauer + " Stunden.";
//Ausgabe auf dem Bildschirm
JOptionPane.showMessageDialog (null, ausgabe);
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 284
Version 2.0: Genauere Zeitangaben
Die Eingabe der Zeiten soll im Format hh:mm:ss erfolgen.
Die Laufzeit soll ebenfalls mit Stunde, Minute und Sekunde ausgegeben
werden.
Grundlagen der Informatik
WS 2006/2007
Seite 285
import javax.swing.JOptionPane;
class LaufZeitApp {
public static void main (String args[]){
String ersteEingabe, zweiteEingabe, ausgabe;
Uhrzeit start, ankunft;
String dauer;
//Einlesen der Eingabestrings:
ersteEingabe = JOptionPane.showInputDialog ("Startzeit
(hh:mm:ss)");
zweiteEingabe = JOptionPane.showInputDialog ("Ankunftszeit
(hh:mm:ss)");
//Erzeugung zweier Objekte der Klasse Uhrzeit:
start = new Uhrzeit (ersteEingabe);
ankunft = new Uhrzeit (zweiteEingabe);
Grundlagen der Informatik
WS 2006/2007
Seite 286
//Erzeugung eines speziellen Läufers
Laeufer teilnehmer = new Laeufer(start,ankunft);
//Berechnnung Laufdauer:
dauer = teilnehmer.getLaufDauer();
//erzeuge Ausgabestring:
ausgabe = "Die Laufzeitzeit betraegt " +dauer ;
//Ausgabe auf dem Bildschirm
JOptionPane.showMessageDialog (null, ausgabe);
System.exit( 0 );
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 287
/*
Die Klasse ermöglicht die Berechnung der Laufzeit eines Laeufers
*/
class Laeufer{
//Attribute
private Uhrzeit startZeit, ankunftsZeit;
private String laufDauer;
//Konstruktor
Laeufer(Uhrzeit startZeit, Uhrzeit ankunftsZeit){
this.startZeit = startZeit;
this.ankunftsZeit = ankunftsZeit;
}
//Methode
String getLaufDauer (){
laufDauer = ankunftsZeit.minus(startZeit);
return laufDauer;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 288
//Die Klasse ermöglicht die Berechnung der Zeiten im Format hh:mm:ss
class Uhrzeit{
//Attribute
private int stunde, minute, sekunde;
//Konstruktor
Uhrzeit (String text) {
stunde = Integer.parseInt (text.substring(0,2));
minute = Integer.parseInt (text.substring (3,5));
sekunde = Integer.parseInt (text.substring (6,8));
}
//Methoden
int rechneInSekunden() {
int sekundenZeit; //Uhrzeit in Sekunden (lokale Variable)
sekundenZeit = sekunde;
sekundenZeit = sekundenZeit + 60*minute;
sekundenZeit = sekundenZeit + 3600*stunde;
return sekundenZeit;
}
Grundlagen der Informatik
WS 2006/2007
Seite 289
String minus (Uhrzeit zeit){
//subtrahiert die Uhrzeit zeit und gibt String in h,m,s zurueck
int differenz, diffStunde, diffMinute, diffSekunde;
String rueckgabe ="";
differenz = rechneInSekunden() - zeit.rechneInSekunden();
diffStunde = differenz / 3600;
differenz = differenz % 3600;
diffMinute = differenz / 60;
diffSekunde = differenz % 60;
rueckgabe += diffStunde + " h ";
rueckgabe += diffMinute + " min ";
rueckgabe += diffSekunde +" sec ";
return rueckgabe;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 290
Die Methode substring()
Sie ist definiert durch substring (int beginn, int ende).
Sei text ein String. Dann liefert der Methodenaufruf
text.substring(3,5), einen Teilstring, der aus dem 4. bis 5. Element von
text besteht (Strings beginnen mit dem Index 0).
Beispiel:
String text = “HALLO“;
String text2 = text.substring(0,2);
ergibt text2 = “HA“;
Grundlagen der Informatik
WS 2006/2007
Seite 291
Referenzdatentypen im Vergleich zu primitiven Datentypen
In Java gibt es fundamentale Unterschiede zwischen Objekten und Daten
vom primitiven Datentyp,
d.h. int, double, boolean, char, long, float.
•
Eine Variable eines primitiven Datentyps kann nur genau einen Wert zu
einem bestimmten Zeitpunkt annehmen
•
Objekte bestehen aus Daten, d.h. aus Objekten oder primitiven Datentypen
und haben Methoden.
Grundlagen der Informatik
WS 2006/2007
Seite 292
•
Variablen vom primitiven Datentyp belegen einen bestimmten Platz im
Speicher. Bei Verwendung im Programm wird ihr Wert kopiert und
verarbeitet (Bsp. int a = 5; int b = a).
•
Eine Variable, die ein Objekt darstellt, ist dagegen eine Referenz auf den
Speicherort, an dem sich das Objekt befindet, also seine Speicheradresse.
Man nennt sie daher Referenzdatentypen.
•
Bei Verwendung im Programm wird die Referenz übergeben.
Das nächste Programm veranschaulicht den Unterschied zwischen
Referenzdatentypen und primitiven (elementaren) Datentypen.
Grundlagen der Informatik
WS 2006/2007
Seite 293
Eine Klasse IntZahlen sei wie folgt definiert:
public class IntZahlen {
//Attribut
int zahl;
//Konstruktor
IntZahlen ( int zahl) {
this.zahl = zahl;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 294
import javax.swing.*;
public class VergleichDatenTypen {
public static void main (String args[]) {
IntZahlen zahl1, zahl2;
int x, y;
String ausgabe;
//primitive Datentypen
x = 1;
y = x;
y = 2;
//Objekte
zahl1 = new IntZahlen (1);
zahl2 = zahl1;
zahl2.zahl = 2;
//Ausgabe
ausgabe = "x = "+ x +"\ny = " +y;
ausgabe += "\nWert der Zahl des Objektes zahl1: " + zahl1.zahl;
ausgabe += "\nWert der Zahl des Objektes zahl2: " + zahl2.zahl;
JOptionPane.showMessageDialog ( null, ausgabe) ;
System.exit (0);
Grundlagen der Informatik
}
WS 2006/2007
Seite 295
}
Die Applikation erzeugt die folgende Ausgabe
•
Da x und y primitive Datentypen sind, wird durch y = x der Wert kopiert.
Eine Veränderung von y führt daher nicht zu einer Veränderung von x.
• zahl1 und zahl2 sind vom Datentyp IntZahlen, also von einem
Referenzdatentyp. Somit wird durch zahl2 = zahl1 bewirkt, dass beide
Variablen auf das selbe Objekt zeigen und dieses verändern können.
Grundlagen der Informatik
WS 2006/2007
Seite 296
Gleichheit von Objekten und die Methode equals()
Durch objekt1 == objekt2 werden die Referenzen auf die Objekte
miteinander verglichen.
Möchte man aber die Inhalte zweier Objekte miteinander vergleichen, so kann
die Methode equals() verwendet werden.
string1.equals(string2) ist true, wenn die beiden Strings string1 und
string2 identisch sind.
objekt1.equals(objekt2) ist dagegen true, wenn die Referenzen
übereinstimmen.
Um die Inhalte auf Gleichheit zu Überprüfen müssen die einzelnen Attribute
explizit angegeben werden bzw. die Methode equals() überschrieben werden.
Beispiel: objekt1.name.equals(objekt2.name)
Grundlagen der Informatik
WS 2006/2007
Seite 297
Garbage Collection (Müllsammlung)
•
Werden Objekte mit new angelegt, so wird im Hauptspeicher Platz für diese
Objekte bereitgestellt.
•
Im Gegensatz zu anderen Programmiersprachen wird dieser Speicherplatz
wieder freigegeben, sobald er nicht mehr benötigt wird.
•
Diese Freigabe geschieht, indem eine sog. garbage collection automatisch
durchgeführt wird.
•
Die garbage collection startet dann, wenn Java Speicherplatz benötigt.
•
Man kann sie auch explizit mit System.gc() aufrufen.
Grundlagen der Informatik
WS 2006/2007
Seite 298
Exceptions
•
Exceptions sind in Java Objekte. Man unterscheidet zwischen
•
Error: schwere Systemfehler
•
Exception: „normaler Fehler“, der vom Programm kontrolliert werden
kann
•
Eine „Ausnahme“ oder Exception zeigt an, dass ein Problem während der
Ausführung eines Programms aufgetaucht ist, z.B. Division durch 0,
Bereichsüberschreitung von Array-Indizes, Nichtkompatible Datentypen beim
Typumwandeln, unbekannte Datei beim Lesen,....
•
Solche Fehler bringen ein Programm meist zum Absturz, wenn man sie nicht
abfängt.
Grundlagen der Informatik
WS 2006/2007
Seite 299
Beispiele für Exceptions
Werden die Array Grenzen nicht eingehalten (s. Programmbeispiel), so wird
zur Laufzeit die folgende Exception erzeugt und das Programm wird beendet.
class ArrayGrenzen{
public static void main (String args[]) {
int a[] = new int [10];
//Initialisierung
for(int i = 0;i< a.length;i++)
a[i] = i*i;
for (int i = a.length; i>=0;i--)
System.out.println (a[i]);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 300
Wird im Programm durch 0 dividiert, so wird zur Laufzeit die folgende
Exception erzeugt und das Programm wird beendet.
Falsche Formate erzeugen eine NumberFormatException
class Cast{
public static void main (String args[]) {
String s1="12", s2 = "a";
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 301
•
Exceptions sind Objekte der Klasse Exception aus dem Paket java.lang
oder einer Unterklasse (z.B. NumberFormatException).
•
Errors sind Objekte der Klasse Error.
•
Die Klassen Exception sowie Error sind Unterklassen von Throwable.
•
„Ausnahmen“, die von Error oder von RuntimeException abgeleitet sind,
sind unkontrollierte Ausnahmen
•
Alle anderen „Ausnahmen“ sind kontrollierte Ausnahmen.
Grundlagen der Informatik
WS 2006/2007
Seite 302
Exception Handling
•
Eine Ausnahme Behandlung kann in Java durch eine Kombination von einem
try- (Versuchen) mit einem oder mehreren catch- (Abfangen) Codeblöcken
erfolgen. Der try-Block legt den Programmbereich fest, der überwacht wird,
d.h. der eine Ausnahme erzeugen/auswerfen könnte.
try{
Anweisungen, die eine Ausnahme verursachen können;
}catch (Ausnahmetyp e1){
Anweisungen zum Reagieren und Beheben;
}catch (Ausnahmetyp e2){
Anweisungen zum Reagieren und Beheben;
}…weitere catches
Grundlagen der Informatik
WS 2006/2007
Seite 303
Das folgende Programm reagiert auf den Laufzeitfehler im Programm Cast.java
class Cast2{
public static void main (String args[]) {
String s1="12", s2 = "a", s3 = "9";
int i1,i2,i3 ;
i1= i2 = i3 = 0;
try{
i1 = Integer.parseInt(s1);
i2 = Integer.parseInt(s2);
i3 = Integer.parseInt(s3);
}catch(NumberFormatException e){
System.out.println("Keine Zahl");
}
System.out.println(i1+i2+i3);
System.out.println(i1*i3);
}
}
Das Programm liefert die Ausgabe
Grundlagen der Informatik
WS 2006/2007
Seite 304
Optional kann nach dem catch-Block ein finally-Block folgen.
Der Teil im finally Block wird immer ausgeführt, auch wenn in try und
catch ein return, break, oder continue steht.
Die Syntax lautet dann
try{
Anweisungen, die eine Ausnahme verursachen können;
}catch (Ausnahmetyp e1){
Anweisungen zum Reagieren und Beheben;
}
…weitere catches
finally {
Anweisungen;
}
Grundlagen der Informatik
WS 2006/2007
Seite 305
Die folgende Applikation Wochentag2.java fängt Fehler der Kategorie
ArrayIndexOutOfBoundsException und NumberFormatException sowie
eine Exception, die durch das Klicken des Abbruch-Buttons erzeugt wird.
Hier wird der Fehler explizit mit der throw-Anweisung ausgeworfen.
Eine Exception kann mit throw new Ausnahmetyp(); geworfen (erzeugt)
werden.
Grundlagen der Informatik
WS 2006/2007
Seite 306
import javax.swing.JOptionPane;
class Wochentag2{
public static void main (String args[]) {
String eingabe, ausgabe; int zahl;
String wochentag[] =
{"Sonntag","Montag","Dienstag","Mittwoch",
"Donnerstag","Freitag","Samstag"};
while (true){
try{
eingabe = JOptionPane.showInputDialog ("Eingabe
Wochentag");
if (eingabe == null)
//User klickt "abbrechen"
throw new Exception ("Ende");
int hilf = Integer.parseInt(eingabe);
zahl = hilf-1;
//Tag 1 ist Sonntag, Tag 7 ist Samstag
Grundlagen der Informatik
WS 2006/2007
Seite 307
ausgabe = "Der Tag "+hilf+" ist ein“+wochentag[zahl];
JOptionPane.showMessageDialog(null,ausgabe);
}catch (ArrayIndexOutOfBoundsException ab){
JOptionPane.showMessageDialog(null, "kein Wochentag");
}
catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null,"keine Zahl!");
}
catch (Exception e){
JOptionPane.showMessageDialog(null,"Tschuess");
System.exit(0);
}
}
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 308
throws im Methodenkopf angeben
Neben dem Einzäunen von problematischen Blöcken durch einen try- und catchBlock gibt es noch eine andere Möglichkeit auf Exceptions zu reagieren:
Im Methodenkopf wird eine throws-Klausel eingeführt.
Beispiel String readFirstLineFromFile (String filename)
throws java.io.IOException{ ….};
Dadurch zeigt eine Methode an, dass sie möglicherweise eine Exception
auswerfen wird, aber diese nicht selbst behandelt, sondern diese unter
Umständen an die aufrufende Methode weitergibt.
Eine Methode muss alle kontrollierten Ausnahmen, die sie auslösen kann, auch
deklarieren. (D.h. Ausnahmen, die von der Klasse Error und
RuntimeException abgeleitet sind, müssen nicht angekündigt werden).
Grundlagen der Informatik
WS 2006/2007
Seite 309
Vererbung
•
Die Vererbung ist eines der wesentlichsten Konzepte der
Objektorientierung.
•
Vererbung ist ein Mechanismus, der es erlaubt, bestehenden
Programmcode zu benutzen und ihn den eigenen Bedürfnissen
anzupassen.
•
Die abgeleitete Klasse, d.h. die Subklasse übernimmt die Attribute und
Methoden der Elternklasse (Superklasse).
•
Die Subklasse kann selbst entscheiden, welche Attribute und Methoden
sie übernehmen will und welche sie hinzufügen bzw. überschreiben will.
•
In Java kann jede Subklasse nur eine Superklasse haben. Man spricht
von Einfachvererbung.
Grundlagen der Informatik
WS 2006/2007
Seite 310
•
Im folgenden Beispiel ist die Klasse Abteilungsleiter eine Subklasse von
Mitarbeiter.
•
Dies wird durch das reservierte Wort extends im Kopf der Klasse
ausgedrückt. class Abteilungsleiter extends Mitarbeiter
•
Ein Objekt der Klasse Abteilungsleiter kann damit die Attribute und
Methoden von Mitarbeiter nutzen. Im Beispiel wird ein zusätzliches
Attribut eingesetzt sowie zwei Methoden hinzugefügt.
Grundlagen der Informatik
WS 2006/2007
Seite 311
public class Mitarbeiter{
private String name;
private int personalNummer;
private double gehalt;
void setName (String name){
this.name = name;
}
void setPersonalnummer(int personalNummer){
this.personalNummer = personalNummer;
}
void setGehalt (double gehalt){
this.gehalt = gehalt;
}
void drucke () {
System.out.print("\nName: " + name);
System.out.print ("\tPersonalnummer: " + personalNummer);
System.out.print("\tGehalt: " + gehalt);
}
void erhoeheGehalt (double betrag){
gehalt += betrag;
}
Grundlagen der Informatik
}
WS 2006/2007
Seite 312
public class Abteilungsleiter extends Mitarbeiter{
//Attribute:
private String abteilung; //zusätzliches Attribut
//Methoden
void setAbteilung (String abteilung){
this.abteilung = abteilung;
}
void ausgabeAbteilung () {
System.out.println ("\tLeiter Abteilung: " + abteilung);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 313
public class MitarbeiterApplikation{
public static void main(String args[]){
Mitarbeiter uwe = new Mitarbeiter();
uwe.setName("Maier");
uwe.setPersonalnummer(13);
uwe.setGehalt(2000);
uwe.drucke();
Abteilungsleiter anja = new Abteilungsleiter();
anja.setName ("Mueller");
anja.setPersonalnummer ( 25);
anja.setGehalt ( 4030);
anja.setAbteilung ("F3O Projekte");
anja.erhoeheGehalt (300);
anja.drucke();
anja.ausgabeAbteilung ();
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 314
Die Applikation liefert die Ausgabe
Grundlagen der Informatik
WS 2006/2007
Seite 315
Methoden überschreiben
Es ist auch möglich, bestehende Methoden in der Subklasse zu
überschreiben.
Beim Überschreiben definiert man eine Methode in der Subklasse exakt so,
wie sie in der Elternklasse definiert ist. Wird die Methode in der Kindklasse
aufgerufen, wird nicht die geerbte Methode der Elternklasse (Superklasse)
sondern die der Kindklasse benutzt.
Im nächsten Beispiel wird die Methode drucke() überschrieben.
Grundlagen der Informatik
WS 2006/2007
Seite 316
Mit dem reservierten Wort super kann auf die Methoden und Attribute der
Mutterklasse zugegriffen werden.
Im Beispiel ist allerdings ein super.gehalt nicht möglich, da die Attribute in
der Superklasse mit private geschützt sind.
Grundlagen der Informatik
WS 2006/2007
Seite 317
public class Abteilungsleiter extends Mitarbeiter{
//Attribute:
private String abteilung; //zusätzliches Attribut
void setAbteilung (String abteilung){
this.abteilung = abteilung;
}
//Methode drucke() wird überschrieben
void drucke () {
super.drucke();
System.out.println ("\tLeitung Abteilung: " +abteilung);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 318
Das Arbeiten mit Konstruktoren
Im nächsten Beispiel ändern wir nun die Klassen, indem wir Konstruktoren
verwenden.
Der Konstruktor der Subklasse muss als erste Anweisung den
Konstruktoraufruf der Suberklasse haben. Dieser Aufruf erfolgt auch mit
super, im Beispiel
super (name,personalNummer,gehalt);
Grundlagen der Informatik
WS 2006/2007
Seite 319
public class Mitarbeiter{
//Attribute:
private String name;
private int personalNummer;
private double gehalt;
//Konstruktor:
public Mitarbeiter(String name, int personalNummer, double gehalt){
this.name = name;
this.personalNummer = personalNummer;
this.gehalt = gehalt;
}
//Methoden:
public void drucke () {
System.out.println();
System.out.print ("Name: " + name);
System.out.print ("\tPersonalnummer: " + personalNummer);
System.out.print("\tGehalt: " + gehalt);
}
public void erhoeheGehalt (double betrag){
gehalt += betrag;
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 320
public class Abteilungsleiter extends Mitarbeiter{
//Attribute:
private String abteilung; //zusätzliches Attribut
//Konstruktor
public Abteilungsleiter (String name, int personalNummer,
double gehalt, String abteilung) {
//Aufruf des Konstrukors von Mitarbeiter
super (name, personalNummer,gehalt);
this.abteilung = abteilung;
}
public void drucke () {
super.drucke();
System.out.println ("\tAbteilung: " + abteilung);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 321
public class MitarbeiterApplikation{
public static void main(String args[]){
Mitarbeiter uwe = new Mitarbeiter("Maier", 13, 2000);
Abteilungsleiter anja = new Abteilungsleiter ("Mueller",
25,4030,"F30 Projekte");
uwe.drucke();
anja.erhoeheGehalt(300);
anja.drucke();
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 322
Die Speicherung in einem Array ergibt
public class PersonalVerwaltung{
public static void main(String args[]){
Mitarbeiter personal [] ={new Mitarbeiter("Maier", 13, 2000),
new Abteilungsleiter ("Mueller", 25,4030,"F30 Projekte")};
for (int i = 0;i < personal.length; i++)
personal[i].drucke();
}
}
Beim Aufruf der Methode drucke() wird unterschieden, ob es sich um
ein Objekt Mitarbeiter oder Abteilungsleiter handelt.
Dies bezeichnet man als späte Bindung bzw. Polymorphie.
Grundlagen der Informatik
WS 2006/2007
Seite 323
Späte Bindung - Polymorphie
Hat eine Unterklasse eine Methode der Elternklasse überschrieben, so wird erst
zur Laufzeit dynamisch die entsprechende Objektmethode, passend zum
tatsächlichen Typ des aufrufenden Objekts, ausgewählt.
Die späte Bindung ist eine Anwendung der Polymorphie, wird aber hier
synonym verwendet.
Beispiel: personal[0] und personal[1] sind beide vom Datentyp
Mitarbeiter. personal[1] ist jedoch ein Objekt einer Unterklasse von
Mitarbeiter, nämlich von Abteilungsleiter. Sowohl Mitarbeiter als
auch Abteilungsleiter verfügen über eine Methode drucke(). Erst zur
Laufzeit wird diese Methode gebunden, d.h. erst dann wird entschieden, dass
zu personal[1] die Methode drucke() von Abteilungsleiter gehört.
Grundlagen der Informatik
WS 2006/2007
Seite 324
Bemerkung zur Polymorphie
Polymorphie existiert nicht bei privaten (private), statischen (static) und
finalen (final) Methoden.
final-Methoden können nicht überschrieben werden und sind daher nicht
polymorph gebunden.
Grundlagen der Informatik
WS 2006/2007
Seite 325
Welche Ausgabe liefert die folgende Applikation?
class Klasse1{
public Klasse1(){
System.out.println("Konstruktor Klasse1");
}
public Klasse1 (int dummy){
System.out.println("Konstruktor mit dummy Klasse1");
}
}
class Klasse2 extends Klasse1{
public Klasse2(){
System.out.println("Konstruktor Klasse2");
}
public Klasse2 (int dummy){
super (dummy);
System.out.println("Konstruktor mit dummy Klasse2");
}
}
public class Konstruktor {
public static void main (String args[]){
Klasse2 k = new Klasse2();
Klasse2 l = new Klasse2(1);
}
}
Seite 326
Grundlagen der Informatik
WS 2006/2007
Die Klasse Object
•
Die Klasse Object ist in der Vererbungshierarchie die höchste Klasse.
Sie ist die Elternklasse für alle anderen Klassen.
•
Immer wenn eine Klasse definiert wird, dabei aber keine explizite
Ableitung mittels extends angegeben wird, fügt Java automatisch
extends Object hinzu.
•
Eine Methoden der Klasse Object, die wir bereits kennen gelernt haben
sind:
equals(Object)
Überprüfung auf Gleichheit
Grundlagen der Informatik
WS 2006/2007
Seite 327
Zeichenketten: Die Klassen String und StringBuffer
•
Strings, d.h. Zeichenketten sind in Java Objekte.
•
In Java gibt zwei Klassen von Strings, dies sind die Klassen String und
StringBuffer.
•
Objekte der Klasse String stellen Zeichenketten mit fester Länge, d.h.
konstante Zeichenketten, dar.
•
Objekte der Klasse StringBuffer stellen Zeichenketten dar, die zur
Laufzeit des Programms verkürzt oder verlängert werden können. Zudem
gibt es verschiedene Methoden zur Textbearbeitung.
•
Die Klassen String und StringBuffer sind aus dem Paket
java.lang
Grundlagen der Informatik
WS 2006/2007
Seite 328
Die Klasse String
Objekte der Klasse sind konstante Zeichenketten.
Sie haben folgende Eigenschaften:
• Die Länge eines Strings steht fest und kann nicht mehr verändert werden.
• Der Inhalt des Strings kann nicht verändert werden. D.h. alle Methoden aus der
Klasse String, die zur Manipulation auf das String Objekt angewendet werden,
geben eine entsprechend manipulierte Kopie des Strings zurück.
Grundlagen der Informatik
WS 2006/2007
Seite 329
Eine konstante Zeichenkette mit beispielsweise dem Inhalt „Peter“ wird entweder
durch die Anweisung
String name = "Peter";
oder durch die Anweisung
String name = new String("Peter");
erzeugt.
name ist also in beiden Fällen eine Referenz auf ein Objekt.
Im ersten Fall spricht man von einer impliziter Erzeugung eines String-Objektes.
Grundlagen der Informatik
WS 2006/2007
Seite 330
Der Unterschied ist, dass im zweiten Fall durch den new-Operator auf jeden
Fall ein neues String-Objekt erzeugt wird und damit Speicher belegt wird.
Im ersten Fall muss dies nicht unbedingt der Fall sein.
Bei optimierenden Compilern können String-Objekte, die den gleichen Inhalt
haben und implizit erzeugt werden, wieder verwendet werden.
Beispiel: Durch
String name = "Peter";
String name2 = "Peter";
erzeugen optimierende Compiler nur ein Objekt, auf das die zwei Referenzen
name und name2 beide zeigen.
Grundlagen der Informatik
WS 2006/2007
Seite 331
Zur Erinnerung:
Strings werden mit der Methode equals() verglichen.
if (name.equals(name2))
…….
vergleicht die Inhalte der beiden Strings name und name2.
Auf den nächsten Folien werden einige weitere String-Methoden erläutert
(schauen Sie bitte auch in der API nach).
Grundlagen der Informatik
WS 2006/2007
Seite 332
Länge eines Strings durch length()
Die Methode length() ermittelt die Länge eines Strings.
String a = "Grundlagen";
int l = a.length();
ergibt l = 10
Zeichen ersetzen mit replace()
Die Methode erzeugt ein neuen String indem die Zeichen aus dem Original ersetzt
wurden.
String s1 = "Java";
String s2 = s1.replace('a', 'A' );
liefert für s2 JAvA, d.h. das a wurden in A verändert. s1 bleibt unverändert.
Grundlagen der Informatik
WS 2006/2007
Seite 333
Stringteile extrahieren mit substring()
Die Methode substring(a,b) liefert einen neuen String als Teilstring des
Originals. a gibt die Startposition an, b die erste Position, die nicht mehr zum
Substring gehören soll.
String subtitel = thema.substring(1,3);
System.out.println(subtitel); ergibt als Ausgabe
av
Grundlagen der Informatik
WS 2006/2007
Seite 334
Anfang und Ende des Strings mit startsWith() und endsWith()
Die Methode startsWith(anfang) überprüft, ob der String mit anfang anfängt.
String titel = "Titel: Grundlagen der Informatik";
boolean s = titel.startsWith("Titel");
System.out.println(s);
ergibt also true.
Die Methode endsWith(ende) überprüft, ob der String mit ende aufhört.
boolean ende = titel.endsWith ("Informatik");
System.out.println(ende);
ergibt true.
Grundlagen der Informatik
WS 2006/2007
Seite 335
Zeichen im String suchen mit indexOf()
Die Methode indexOf(zeichen) gibt die Position aus, an der das zeichen das
erste mal im String vorkommt. Mit String thema = "Java";
int p = thema.indexOf ('a');
ergibt sich für p der Wert 1.
Ist das Zeichen im String nicht enthalten, so liefert die Methode den Wert –1.
Suchen eines Zeichens ab einer bestimmten Position wird durch Angabe eines
weiteren Parameters ermöglicht:
int p = thema.indexOf ('a'‚2);
ergibt für p den Wert 3.
Grundlagen der Informatik
WS 2006/2007
Seite 336
Ist eine Zeichenfolge im String vorhanden?
Seit Java 5 ist es mit Hilfe der Methode contains(zeichenkette) möglich,
innerhalb eines String eine Zeichenkette zu suchen. Die Methode gibt true zurück,
falls die Zeichenkette im String vorhanden ist und false, falls nicht.
String s = "Informatik";
s.contains("for");
ergibt true.
Grundlagen der Informatik
WS 2006/2007
Seite 337
Vergleich zweier Strings auf „Größe“ mit compareTo()
Durch den Methodenaufruf string1.compareTo(string2) werden die beiden
Strings string1 und string2 auf ihre lexikographische Größe verglichen.
Der Rückgabewert ist vom Datentyp int. Er ist 0 bei Gleichheit, negativ, falls
string1 lexikographisch kleiner ist als string2 und positiv, falls string1
lexikographisch größer als string2 ist.
String string1 = "Peter", string2 = "Tina",
string3 = "Peter" , string4 = "Andrea";
Dann ist
string1.compareTo(string2);
kleiner als 0
string1.compareTo(string3);
gleich 0
string1.compareTo(string4); größer als 0
Grundlagen der Informatik
WS 2006/2007
Seite 338
Die Klasse StringBuffer
StringBuffer-Objekte sind Zeichenketten mit folgenden Eigenschaften:
•
Die Länge der Zeichenkette ist nicht festgelegt. Sie vergrößert sich
automatisch, wenn im StringBuffer-Objekt weitere Zeichen angefügt werden
und der vorhandene Platz nicht ausreicht.
•
Der Inhalt einer Instanz der Klasse StringBuffer lässt sich verändern.
D.h. die Methoden aus der Klasse StringBuffer, die zur Manipulation auf
das StringBuffer Objekt angewendet werden, manipulieren das StringBuffer
Objekt selber und geben es zusätzlich zurück.
Grundlagen der Informatik
WS 2006/2007
Seite 339
Das Erzeugen eines StringBuffer-Objektes
StringBuffer-Objekte müssen immer mit Hilfe des new-Operators erzeugt
werden.
Es gibt insgesamt drei Konstruktoren für die Klasse StringBuffer.
• StringBuffer()
Erzeugt StringBuffer-Objekt, das zunächst 16 Zeichen aufnehmen kann
• StringBuffer(int length)
Erzeugt StringBuffer-Objekt, das length Zeichen aufnehmen kann
• StringBuffer(String str)
Es wird ein StringBuffer-Objekt erzeugt und mit einer Kopie des Strings
str initialisiert. Zusätzlich wird bereits Platz für 16 weitere Zeichen
eingeplant.
Grundlagen der Informatik
WS 2006/2007
Seite 340
Die Länge eines StringBuffer-Objektes lesen und setzen
Unterschieden wird zwischen den Methoden length() und capacity().
•
Die Methode length() ermittelt die Anzahl der enthaltenen Zeichen.
•
Die Methode capacity() ermittelt die Kapazität, d.h. den gesamten
Speicherplatz ( belegter und freier Speicherplatz). Diese Kapazität wird
automatisch angepasst, wenn weitere Zeichen eingebaut werden. Man kann
sie aber auch manuell einstellen.
Grundlagen der Informatik
WS 2006/2007
Seite 341
Beispiel
StringBuffer text1 = new StringBuffer();
StringBuffer text2 = new StringBuffer(20);
StringBuffer text3 = new StringBuffer("Vorlesung");
System.out.println(text1);
System.out.println(text1.length());
System.out.println(text1.capacity());
//Ausgabe 0
//Ausgabe 16
System.out.println(text2);
System.out.println(text2.length());
System.out.println(text2.capacity());
//Ausgabe 0
//Ausgabe 20
System.out.println(text3);
System.out.println(text3.length());
System.out.println(text3.capacity());
//Ausgabe „Vorlesung“
//Ausgabe 9
//Ausgabe 25
Grundlagen der Informatik
WS 2006/2007
Seite 342
Zeichen anhängen, einfügen, löschen
•
Die Methode append() hängt Werte an eine Zeichenkette an. Der interne
Platz wird dabei –falls nötig- automatisch vergrößert. Ein neues StringBufferObjekt wird nicht erzeugt.
•
Durch die Methode insert() können Zeichenketten und primitive
Datentypen an einer beliebigen Stelle eingefügt werden. Der erste Parameter
der Methode gibt die gewünschte Position an (1. Zeichen hat Position 0). Der
zweite Parameter gibt den Inhalt an.
•
Die Methode setCharAt() überschreibt einzelne Zeichen. Der erste
Parmameter gibt die Position des zu ersetzenden Zeichens an, der zweite
Parameter gibt das neue Zeichen an.
Grundlagen der Informatik
WS 2006/2007
Seite 343
•
Die Methode reverse() dreht die Reihenfolge der Zeichen um.
•
Die Methode delete() löscht einen Teil der Zeichenkette. Der erste
Parameter gibt die Position des ersten zu löschenden Zeichens an, der zweite
Parameter gibt die Position des ersten Zeichens an, das nicht mehr gelöscht
werden soll.
Grundlagen der Informatik
WS 2006/2007
Seite 344
Beispiel
class BeispielStringBuffer{
public static void main (String args[]){
StringBuffer text3 = new StringBuffer("Vorlesung");
text3.append(" Java");
System.out.println(text3);
text3.insert(9," Ueber");
System.out.println(text3);
Ausgabe des
Programms
text3.setCharAt(10,'u');
System.out.println(text3);
text3.reverse();
System.out.println(text3);
text3.delete(4,10);
System.out.println(text3);
text3.reverse().append(" Teil").append(" 2");
System.out.println(text3);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 345
Vergleiche von Zeichenketten als String und StringBuffer
Um zwei StringBuffer-Objekte bzw. ein StringBuffer- und ein String-Objekt auf
Gleichheit zu überprüfen, muss das/die StringBuffer-Objekte in Strings
umgewandelt werden:
•
Umwandeln des/der StringBuffer-Objekte in Strings mit Hilfe der Methode
toString() und danach Vergleich mit equals():
StringBuffer text1 = new StringBuffer("Java");
String text2 = "Java";
System.out.println(text2.equals(text1.toString()));
Grundlagen der Informatik
WS 2006/2007
Seite 346
Vergleiche von Zeichenketten als String und StringBuffer
Der Vergleich eines StringBuffer-Objektes mit einem String kann seit Version 1.4
auch mit Hilfe der Methode contentEquals() erfolgen:
•
Benutzung der Methode contentEquals(StringBuffer)
System.out.println(text2.contentEquals(text1));
Grundlagen der Informatik
WS 2006/2007
Seite 347
Ein weiteres Beispiel
Testen, ob der String s ein Palindrom ist.
Palindrome lesen sich von vorne genauso wie von hinten, z.B. OTTO
import javax.swing.*;
class Palindrom{
public static void main (String args[]){
String s = JOptionPane.showInputDialog (null,
"Geben Sie einen String ein");
boolean isPalindrom =
s.contentEquals(new StringBuffer(s).reverse());
if (isPalindrom)
System.out.println(s+" ist ein Palindrom");
else
System.out.println (s +" ist kein Palindrom");
System.exit(0);
}
}
Grundlagen der Informatik
WS 2006/2007
Seite 348
Bemerkung zum Palindrom-Beispiel
Die Zeile
boolean isPalindrom =
s.contentEquals(new StringBuffer(s).reverse());
kann auch ersetzt werden durch
boolean isPalindrom =
new StringBuffer(s).reverse().toString().equals(s);
Grundlagen der Informatik
WS 2006/2007
Seite 349