Java - ias.uni-stuttgart.de

Universität Stuttgart
Institut für Automatisierungs- und Softwaretechnik
Prof. Dr.-Ing. Dr. h. c. P. Göhner
Java-Kurs am IAS
Java
am IAS
© 2012, IAS
1
Kursüberblick
Erster Tag
Teil 1:
 Erster Überblick
 Java Grundlagen
Teil 2:
 Grundlagen der Objektorientierung
 Klassen und Objekte in Java
Java
am IAS
© 2012, IAS
2
Erster Überblick
Was ist Java?
 ein Projekt von Sun:
• Programmierumgebung
• WWW-Browser
 die Programmierumgebung (JavaDevelopersKit) besteht
aus:
•
•
•
•
einem Java-Compiler
verschiedenen Bibliotheken
einem Laufzeitsystem
einem Debugger
 Kennzeichen der Java Programmiersprache:
•
•
•
•
•
Java
am IAS
objektorientiert
plattformunabhängig
streng typisiert
sicher in Netzen
ähnliche Syntax wie C++
© 2012, IAS
3
Erster Überblick
Geschichtliches ...
 August 1991: James Gosling (SUN) entwickelt Oak (Java)
 Entwicklungsziel: einfache Programmiersprache für
Consumer Electronics (z.B Interactive TV, Settop-Boxes)
 Anfang 1994: Nach Misserfolgen im Bereich Consumer
Electronics und zunehmendem Erfolg des WWW Neuausrichtung auf Internet
 Februar 1995: Erste Version von Oak (jetzt: Java) und
einem Java WWW-Browser (Hotjava) werden veröffentlicht
 August 1995: SUN lizensiert Java an Netscape, IBM und
Microsoft
 Dezember 1998: JDK 1.2
 aktuelle Version 7
Java
am IAS
© 2012, IAS
4
Erster Überblick
Allgemeine Konzepte
 Java wird interpretiert (schneller Entwicklungszyklus)
 Hohe Zuverlässigkeit und Robustheit durch
• Speichermanager
• Verzicht auf (herkömmliche) Zeigertechniken
• strikte Typenüberprüfung zur Kompilier- und Laufzeit
 hohe Verfügbarkeit - Code kann jederzeit über das
Netzwerk nachgeladen werden
 Portabilität - “Write once, run everywhere”
 GUI-Klassenbibliothek (AbstractWindowingToolkit)
Java
am IAS
© 2012, IAS
5
Erster Überblick
Plattformunabhängigkeit
JavaInterpreter
(Pentium)
Java-Compiler
(Pentium)
JavaBytecode
(plattformunabhängig)
JavaCode
JavaInterpreter
(SPARC)
Java-Compiler
(SPARC)
*.class
*.java
JavaInterpreter
(...)
...
Java
am IAS
© 2012, IAS
6
Erster Überblick
Vergleich mit C++ (1)
 Java baut auf C++ auf:
• größtenteils identische Syntax
• Ausnahmebehandlung (exception handling)
• Meta-Objekt-Informationen
 Java vermeidet folgende (teilweise “kritische”) C++
Elemente:
•
•
•
•
Zeiger (Pointer)
Mehrfachvererbung
Präprozessor, keine Header-Dateien
generischen Klassen, Templates
 Java enthält zusätzliche Elemente
•
•
•
•
Java
am IAS
Garbage Collection
Interface-Konzept
Unicode
Threads
© 2012, IAS
7
Erster Überblick
Vergleich mit C++ (2)
 Java ist “schlechter” als C++:
• Java ist nicht standarisiert (Sprache und Bibliotheken)
• C++ Code ist hardwarenäher
Java
am IAS
© 2012, IAS
8
Erster Überblick
Werkzeuge des JDK
 Interpreter (Java Virtual Machine): java
 Testumgebung für Applets:
appletviewer
 Java-Compiler: javac
 Generierung von HTML-Dokumentation
für Klassen: javadoc
 Java-Debugger: jdb
 Headerfile-Generator zur Einbindung
von
C-Funktionen: javah
werden im Rahmen
des Kurses nicht
behandelt!
 Disassembler für Java-Bytecode: javap
JDK kostenlos verfügbar:
http://www.oracle.com/technetwork/java/javase/downloads/
index-jsp-138363.html#javasejdk
Java
am IAS
© 2012, IAS
9
Erster Überblick
Applikation contra Applet
 Applikation:
• “normales”, Java-Programm, vergleichbar mit anderen
(interpretierten) Programmiersprachen
• Bytecode wird von einem Interpreter ausgeführt
 Applets:
• werden in HTML-Seiten eingebunden und von Web-Browsern
ausgeführt
• können über das Netz geladen werden
• unterliegen strengen Sicherheitsanforderungen
(z.B. kein Schreiben im lokalen Dateisystem)
• ermöglichen interaktive Web-Seiten
Java
am IAS
© 2012, IAS
10
Erster Überblick
HelloWorld-Applikation (1)
// Datei: HelloWorld.java
public class HelloWorld {
public static void main( String[] args ) {
System.out.println(“Hello World!”);
}
}
 das gesamte Programm befindet sich innerhalb der
Klassendefinition public class HelloWorld {}
 Java-Programm = Menge von Klassendefinitionen
 die Klassendefinition HelloWorld muss in einer
gleichnamigen Datei HelloWorld.java abgespeichert sein
 main()-Methode ist der Einstiegspunkt des Programms
 Bildschirmausgabe mit System.out.println()
Java
am IAS
© 2012, IAS
11
Erster Überblick
HelloWorld-Applikation (2)
 Übersetzung der Applikation (Compiler):
% javac HelloWorld.java
 nach fehlerfreier Übersetzung entsteht
die Bytecode-Datei: HelloWorld.class
 ausführbares Programm = Menge von .class-Dateien
 Ausführen der Applikation (Interpreter):
% java HelloWorld
 Ausgabe von “HelloWorld” auf dem Bildschirm
Java
am IAS
© 2012, IAS
12
Erster Überblick
HelloWorld-Applet (1)
// Datei: HelloWorld.java
import java.awt.Graphics;
public class HelloWorld extends java.applet.Applet {
public void paint( Graphics g ) {
g.drawString(“Hello World!”, 50, 25);
}
}
 import ermöglich Zugriff auf AWT-Bibliothek
(Abstract Windowing Toolkit, JDK)
 keine main-Methode
 Überschreiben von vorgegebenen Methoden (paint),
die in der AWT-Klasse Applet definiert sind
 Compiler-Aufruf wie bei Applikation
Java
am IAS
© 2012, IAS
13
Erster Überblick
HelloWorld-Applet (2)
// minimale HTML-Datei mit eingebundenem Applet
<HTML>
<HEAD>
<TITLE>HelloWorld Applet</TITLE>
</HEAD><BODY>
<APPLET CODE=“HelloWorld.class” WIDTH=100 HEIGHT=100>
</APPLET>
</BODY>
</HTML>
 CODE gibt Name der Appletklasse an
 WIDTH und HEIGHT bestimmen die (Pixel-)Größe des Applets
 HTML-Datei und HelloWorld.class sollten im gleichen
Verzeichnis liegen
 HTML-Datei in Java-fähigen Browser oder mit
appletviewer aufrufen
Java
am IAS
© 2012, IAS
14
Kursüberblick
Erster Tag
Teil 1:
 Erster Überblick
 Java Grundlagen
Teil 2:
 Grundlagen der Objektorientierung
 Klassen und Objekte in Java
Java
am IAS
© 2012, IAS
15
Java Grundlagen
Prinzip: Die Syntax von Java ist stark an C/C++
angelehnt und größtenteils identisch.
Anweisungen
 einzelne Java-Operationen:
•
•
•
•
•
Zuweisungen (int i = 1)
Ablaufsteuerung (if/else, do-while)
Methodenaufrufe (System.out.println(“Hallo”))
Instanziierungsaufrufe (Date today = new Date())
sonstige Anweisungen (import java.awt.Font)
 Wichtig: Anweisungen werden durch Semikolon (;)
getrennt, z.B.:
import java.awt.Font;
int i = 1;
System.out.println(“Hallo”);
Java
am IAS
© 2012, IAS
16
Java Grundlagen
Variablen (1)
 Stellen im Speicher, die Werte aufnehmen können
 bestehen aus Typ, Namen und Wert:
int i = 12;
 müssen vor der Benutzung deklariert werden:
zaehler = 7;
// Fehler: Variable zaehler unbekannt!
 Deklaration mit Anfangswerten erlaubt:
boolean muede = false;
 Mehrfachdeklarationen in einer Zeile möglich:
int i = 0, j = 3, k = 5;
 Variablennamen müssen mit einem Buchstaben, einem
Unterstreichungsstrich (_) oder einem Dollarzeichen ($)
beginnen
Java
am IAS
© 2012, IAS
17
Java Grundlagen
Variablen (2)
 Java unterscheidet Groß/Kleinbuchstaben
 aussagekräftige Variablennamen wählen!
 Variablentyp darf sein:
• primitiver Datentyp
• Klassenname
• Array
 neue (benutzerspezifische) Variablentypen können nur
durch neue Klassen erzeugt werden (kein typedef wie in
C/C++!)
Java
am IAS
© 2012, IAS
18
Java Grundlagen
Primitive Datentypen
Typ
Bedeutung
Größe
boolean
true oder false
char
Unicode-Zeichen
16 Bits
byte
Ganze Zahl mit Vorzeichen
8 Bits
short
Ganze Zahl mit Vorzeichen
16 Bits
int
Ganze Zahl mit Vorzeichen
32 Bits
long
Ganze Zahl mit Vorzeichen
64 Bits
float
IEEE 754-Fließkommazahl
32 Bits
double
IEEE 754-Fließkommazahl
64 Bits
1 Bit
 keine Implementierungsabhängigkeiten
Java
am IAS
© 2012, IAS
19
Java Grundlagen
Kommentare
 // Text Kommentar bis zum Ende der Zeile
 /* Text */ mehrzeilige Kommentare möglich, aber kein
Verschachteln von Kommentaren!
 /** Text */ spezielle Kommentare für javadoc
Zeichenketten
 keine Zeichen-Arrays sondern Objekte der Klasse String
 bestehen aus mehreren Zeichen zwischen doppelten
Anführungszeichen (“Hallo”)
 Verkettung (+) möglich (“Hallo” + “, World”)
 können Escape-Zeichen enthalten (Auszug):
neue Zeile
\b
Rückschritt
\\
Backslash
\xdd Hexadezimal
\n
Java
am IAS
\t
\r
\”
\uddd
© 2012, IAS
Tab
Return
doppeltes Anführungszeichen
Unicode-Zeichen
20
Java Grundlagen
Operatoren (1)
 Arithmetik
Operator
Bedeutung
Beispiel
+
*
/
%
Addition
Subtraktion
Multiplikation
Division
Modulo
3 + 4
5 - 7
5 * 5
14 / 7
20 % 7
 Zuweisungen
Java
am IAS
Ausdruck
Bedeutung
x
x
x
x
x
x
x
x
+=
-=
*=
/=
y
y
y
y
=
=
=
=
x
x
x
x
+
*
/
© 2012, IAS
y
y
y
y
21
Java Grundlagen
Operatoren (2)
 Inkrement/Dekrement
Ausdruck
x++
x-++x
--x
Bedeutung
x = x + 1,
x = x – 1,
x = x + 1,
x = x - 1,
Inkrementieren (postfix)
Dekrementieren (postfix)
Inkrementieren (prefix)
Dekrementieren (prefix)
postfix: Der Wert wird nach dem auslesen verändert.
prefix: Der Wert wird bevor dem auslesen verändert.
Bsp.:
int x = 5;
System.out.println(x++);
System.out.println(x);
x = 5;
System.out.println(++x);
System.out.println(x);
Java
am IAS
//
//
//
//
//
//
Initialisierung der Variable x mit dem Wert 5
Ausgabe von „5“
Ausgabe von „6“
Zuweisung des Wertes 5 an die Variable x
Ausgabe von „6“
Ausgabe von „6“
© 2012, IAS
22
Java Grundlagen
Operatoren (3)
 Vergleiche und Boolean
Operator
==
!=
<, >
<=, >=
&&
||
Java
am IAS
Bedeutung
Gleich
Ungleich
Kleiner als, Größer als
Kleiner gleich, Größer gleich
Und
Oder
© 2012, IAS
Beispiel
x == 3
x != 3
x < 3, x > 3
x <= 3, x >= 3
(x > 0) && (x < 1)
(x > 0) || (x < 1)
23
Java Grundlagen
Operatoren (3)
 Bitweise Operatoren
• Operationen auf einzelne Bits in Ganzzahlen (z.B. Verschiebungen,
Komplement, AND, OR, ...)
• spielen in diesem Kurs keine Rolle
 Operatorpräzedenz
• Reihenfolge, in der Ausdrücke mit Operatoren bewertet werden,
z.B y = 6 + 4 / 2 ist 8 und nicht 5 !
• Reihenfolge (kann durch Klammerung geändert werden):
1) Klammern ([], ()) und Methoden- und Variablenzugriffe (.)
2) Inkrement/Dekrementausdrücke (++, --)
3) Multiplikation, Division, Modulo (*, /, %)
4) Addition, Subtraktion (+, -)
5) Bitweise Operationen
6) Vergleiche (<, >, ==, !=)
7) Logische (Boolsche) Operatoren (&&, ||)
8) Zuweisungen (=, +=, -=, *=, /=, ...)
Java
am IAS
© 2012, IAS
24
Java Grundlagen
Operatoren (4)
Beispiel:
// Datei: OperatorTest.java
class OperatorTest {
public static void main(String[] args) {
int x = 6;
int y = 4;
System.out.println(“x +
System.out.println(“x /
System.out.println(“x %
System.out.println(“++x
System.out.println(“--x
y
y
y
:
:
=
=
=
“
“
“
“
“
+
+
+ (x + y));
+ (x / y));
+ (x / y));
(++x));
(--x));
//
//
//
//
//
=
=
=
=
=
10
1
2
7
6
}
}
Java
am IAS
© 2012, IAS
25
Java Grundlagen
Ablaufsteuerung (1)
 if-Anweisung
if( wert >= 1 ){
summe = summe + wert;
}
else {
wert = 0;
}
// Bedingung
// Anweisungen
// alternativer Zweig
// Anweisungen
• else-Zweig ist optional
• bei nur einem Befehl im if/else-Zweig kann die {}Klammerung weggelassen werden:
if( wert >= 1 )
summe = summe + wert;
Java
am IAS
© 2012, IAS
26
Java Grundlagen
Ablaufsteuerung (2)
 switch-Anweisung
switch( wert ){
case 1:
summe++;
case 2:
summe = summe + 2;
break;
default:
summe = 0;
// wert = 1!
// wert = 2!
// springt aus der {}-Klammer
// Vergleich immer erfüllt!
}
• zur Variablen wert passender Ausdruck und/oder DefaultAusdruck wird ausgeführt
Java
am IAS
© 2012, IAS
27
Java Grundlagen
Ablaufsteuerung (3)
 while-Schleife
while( summe >= 1 ){
summe--;
}
// Schleifen-Bedingung
// Anweisungen
• Wiederholung der Anweisungen bis Schleifen-Bedingung falsch
 do-while-Schleife
do{
summe--;
} while( summe >= 1 );
// Anweisungen
• wie while-Schleife, Anweisungen werden jedoch mindestens
einmal durchlaufen
Java
am IAS
© 2012, IAS
28
Java Grundlagen
Ablaufsteuerung (4)
 for-Schleife
for( int i = 0; i < 10; i++ ){
System.out.println(i);
}
// Anweisungen
• zunächst Ausführung der Initialisierungsanweisung (int i =
0)
• Auswertung des Boolschen Ausdrucks ( i < 10 ):
– falls wahr, wird zunächst die Anweisung
(System.out.println(i)) und dann die
Inkrementierunganweisung (i++) ausgeführt
– Ablauf wiederholen solange Boolscher Ausdruck wahr ist
• in der for-Schleife deklarierte Variablen sind nur innerhalb der
Schleife gültig
Java
am IAS
© 2012, IAS
29
Java Grundlagen
Ablaufsteuerung (5)
 continue-Anweisung
for( int i = 0; i < 10; i++ ){
if( i > 6 )
continue;
System.out.println(i);
// continue springt hierher
}
• springt an das Ende des Schleifenrumpfes
 return-Anweisung
return i;
• beendet Methode und liefert (falls vorhanden) Rückgabewert
der Methode
Java
am IAS
© 2012, IAS
30
Java Grundlagen
Zusammenfassung
 Java ist eine objektorientierte Sprache von Sun, die für den
Einsatz in Netzen konzipiert ist
 Portabilität wird durch plattformunabhängigen Bytecode
erreicht:
“Write once, run everywhere”
 Java vereinfacht C++ (Zeiger, Präprozessor) und bietet
zusätzliche Elemente (Garbage Collection)
 mit Java können sowohl “normale” Programme als auch
Applets geschrieben werden
 Anweisungen, Variablen, Operatoren und Ablaufsteuerung
sind bis auf wenige Ausnahmen mit C/C++ identisch
 das JDK ist kostenlos verfügbar
Java
am IAS
© 2012, IAS
31
Kursüberblick
Erster Tag
Teil 1:
 Erster Überblick
 Java Grundlagen
Teil 2:
 Grundlagen der Objektorientierung
 Klassen und Objekte in Java
Java
am IAS
© 2012, IAS
32
Grundlagen der Objektorientierung
Begriffe
 Objektorientierte Analyse
• OOA ist Analysemethode, Anforderungen aus der Perspektive
der Klassen und Objekte, die sich im Vokabular des
Problembereichs finden
 Objektorientiertes Design
• OOD ist Designmethode, Prozess der objektorientierten
Zerlegung
• Notation für Beschreibung der logischen und physikalischen
wie auch statischen und dynamischen Modelle des betrachteten
Systems
 Objektorientierte Programmierung
• Implementierungsmethode, Programme als Ansammlungen
von kooperierenden Objekten
• jedes Objekte ist Exemplar (Instanz) einer Klasse
• alle Klassen sind Elemente einer Klassenhierarchie, die durch
Vererbungsbeziehungen gekennzeichnet ist
Java
am IAS
© 2012, IAS
33
Grundlagen der Objektorientierung
Hauptelemente des Objektmodells
Die folgenden vier Konzepte sind die vier Hauptelemente des
Objektmodells (nach G.Booch)
Fehlt eines dieser vier Elemente, so ist das Modell nicht
objektorientiert:




Java
am IAS
Abstraktion
Kapselung
Modularität
Hierarchie
© 2012, IAS
34
Grundlagen der Objektorientierung
Abstraktion
• konzentriert sich auf die wesentlichen Charakteristika eines
Objekts
• relativ zur Perspektive des Betrachters
Java
am IAS
© 2012, IAS
35
Grundlagen der Objektorientierung
Kapselung
• verbirgt die Details der Objekt-Implementierung
• trennt somit die Schnittstelle einer Abstraktion von ihrer
Implementierung
Java
am IAS
© 2012, IAS
36
Grundlagen der Objektorientierung
Modularität
• packt Abstraktionen in eigenständige Einheiten
• Verbindungen zwischen den Modulen sind die Annahmen, die
die Module gegenseitig übereinander anstellen
Java
am IAS
© 2012, IAS
37
Grundlagen der Objektorientierung
Hierarchie
• Abstraktionen bilden eine
Hierarchie
• Klassenstruktur: “ist-ein”Hierarchie (Vererbung)
• Objektstruktur: “Teil-von”Hierarchie (Aggregation)
Java
am IAS
© 2012, IAS
38
Grundlagen der Objektorientierung
Objekt
 allgemein: Gegenstand des Interesses (einer
Beobachtung, Untersuchung, Messung)
 Objektorientierung: individuelles Exemplar
von
Methode
1
Methode
4
Gegenständen (Auto, Roboter),
Personen (Kunde, Mitarbeiter),
Begriffen der realen Welt (Auftrag) oder
Begriffen der Vorstellungswelt (Strategie)
 Kennzeichen von Objekten:
• Identität: Objekt kann deutlich von anderen
unterschieden werden
• Daten (Variablen): Eigenschaften des Objekts
• Methoden (Operationen): Lesen und
Manipulieren von Daten
Daten
Methode
2
•
•
•
•
Methode
3
 Geheimnisprinzip: Datenzugriff nur über
Methoden
Java
am IAS
© 2012, IAS
39
Grundlagen der Objektorientierung
Klasse
 allgemein: Gruppe von Gegenständen,
Lebewesen, Begriffen mit gemeinsamen
Merkmalen
 Objektorientierung:
ändern Name
“Objekt-Schablone” für
• Objekte mit denselben Variablen
(Daten) und
• denselben Operationen (Methoden)
 Objekt-Erzeugungsmechanismus
Java
am IAS
MitarbeiterKlasse
Name
Gehalt
ändern Gehalt
Mitarbeiter-Objekt
Mitarbeiter-Objekt
ändern Name
ändern Name
Name
Name
Müller
Meier
Gehalt
Gehalt
6.000
5.000
ändern Gehalt
ändern Gehalt
© 2012, IAS
40
Grundlagen der Objektorientierung
Huhn
Klasse
Name :
Größe :
Farbe :
Eier legen()
gackern()
Berta
Kunigunde
Objekte
Elsa
Elfriede
Java
am IAS
© 2012, IAS
41
Grundlagen der Objektorientierung
Vererbung
 Stellt eine Verallgemeinerung / Spezialisierung-Hierarchie
dar
 Eine untergeordnete Klasse erbt Eigenschaften und
Verhalten einer oder mehrerer übergeordneter Klassen
 „...ist ein...“ - Beziehung
Java
am IAS
© 2012, IAS
42
Grundlagen der Objektorientierung
Vererbung
Fahrzeug
Wasserfahrzeug
Landfahrzeug
PKW
Motorrad
Amphibienfahrzeug
Schiff
Cabrio
Java
am IAS
© 2012, IAS
43
Grundlagen der Objektorientierung
Aggregation
 Stellt Beziehung zwischen einem Ganzen und seinen Teilen
dar
 „...hat ein...“ - oder „...ist Teil von...“ - Beziehung
Java
am IAS
© 2012, IAS
44
Grundlagen der Objektorientierung
Aggregation
Auto
Motor
Lenkrad
Rad
Auspuff
Zündkerze
Java
am IAS
© 2012, IAS
45
Grundlagen der Objektorientierung
Unterschied zwischen Vererbung und Aggregation:
Vererbung:
 Ein Cabrio ist ein PKW.
 Ein Cabrio ist ein Fahrzeug.
 Ein Amphibienfahrzeug ist ein Landfahrzeug und ein
Wasserfahrzeug.
Aggregation:
 Ein Auto hat einen Motor, ein Lenkrad, Sitze, ...
 Ein Computer hat eine Grafikkarte, RAM, Prozessor, ...
Java
am IAS
© 2012, IAS
46
Kursüberblick
Erster Tag
Teil 1:
 Erster Überblick
 Java Grundlagen
Teil 2:
 Grundlagen der Objektorientierung
 Klassen und Objekte in Java
Java
am IAS
© 2012, IAS
47
Klassen und Objekte in Java
Programmstruktur (1)
Überblick:
Programm
*.java
*.java
*.java
class
interface
class
...
package
Java
am IAS
© 2012, IAS
48
Klassen und Objekte in Java
Programmstruktur (2)
*.java-Dateien:
 Beinhalten Klassen- und Schnittstellendeklarationen, wobei
(genau) eine Klasse/Schnittstelle als public deklariert sein muss
• Klassen-/Schnittstellenname und Dateiname müssen übereinstimmen
(Groß- und Kleinschreibung beachten)
 Beinhalten package-Anweisung
 Beinhalten import-Anweisungen
Beispiel:
// Datei Test.java
package ias.kurs.java;
import java.awt.*;
public class Test {
...
};
Java
am IAS
© 2012, IAS
49
Klassen und Objekte in Java
Programmstruktur (3)
packages (Pakete):
 Organisationseinheit für Klassen und Schnittstellen
• beliebig tiefe Schachtelung von Paketen ist möglich,
z.B. java.awt.image
• Schachtelungsstruktur wird auf Verzeichnisse abgebildet,
z.B. java/awt/image
• ohne Angabe eines Pakets wird ein namenloses Defaultpackage
zugeordnet
 Legen Namensraum fest
• alle Klassen eines packages können einander direkt referenzieren
• Klassen anderer Pakete müssen explizit importiert (import) oder
qualifiziert (vollständige Pfadangabe) werden
• alle Klassen aus dem Paket java.lang sind standardmäßig importiert
 Zur Steuerung von Zugriffsrechten nützlich
• alle Klassen eines packages können einander sehen
Java
am IAS
© 2012, IAS
50
Klassen und Objekte in Java
Programmstruktur (4)
Java Applikation:
 Durch Einfügen einer main()-Methode in eine Klasse wird eine
Applikation vervollständigt:
// Datei: HelloWorld.java
public class HelloWorld {
public static void main( String[] args ) {
System.out.println(“Hello World!”);
}
}
 Die main()-Methode ist Einstiegspunkt in das Programm
 Die vor main() stehenden Schlüsselwörter (public static
void) sowie die Parameter (String[] args) sind immer gleich
Java
am IAS
© 2012, IAS
51
Klassen und Objekte in Java
Klassen (1)
Klasse
Überblick:
Variablen
Methoden
Konstruktoren
 Variablen (Attribute):
• primitiver Typ: int i;
• Referenz:
Auto meinAuto;
• Array:
int[] intFeld1;
 Methode:
• Operation mit möglichen Rückgabewert (return)
• eindeutig durch Methodenname und Parameter
 Konstruktor:
• Zur Instanzierung von Objekten benötigt
• Default: Klassenname(){};
• weitere Konstruktoren möglich
• kein Rückgabewert!
Java
am IAS
© 2012, IAS
52
Klassen und Objekte in Java
Klassen (2)
Variablen
// Referenz auf Strings
// Motor an/aus
Methode
void starteMotor(){
// Methode starteMotor
if(motorZustand == true)
System.out.println(“Motor ist bereits an!”);
else {
motorZustand = true;
System.out.println(“Motor ist jetzt an!”);
}
}
void zeigeDaten(){
// Methode zeigeDaten
System.out.println(“Das Motorrad ist eine”
+ farbe + “e “ + modell);
}
Methode
Klasse
Beispiel:
// Datei: Motorrad.java
class Motorrad {
String modell, farbe;
boolean motorZustand;
}
Java
am IAS
© 2012, IAS
53
Klassen und Objekte in Java
Klassen (3)
Erklärungen:
 Klassendefinition durch: class Motorrad {}
 drei Variablen:
• Referenz auf Klasse String (Zeichenkette): model und farbe
• vom Datentyp boolean: motorZustand
 zwei Methoden:
• zum Starten des Motors starteMotor();
• zur Ausgabe der Motorraddaten zeigeDaten();
 Einrückungen haben für den Compiler keine Bedeutung
 keine Trennung von Deklarationen und Implementierung
Java
am IAS
© 2012, IAS
54
Klassen und Objekte in Java
Objekterzeugung mit new
 neue Objekte werden aus bestehenden Klassen mit
new-Operator erzeugt:
String str = new String();
Motorrad m2 = new Motorrad();
 Klammern dürfen nicht weggelassen werden!
 der new-Operator weist dem Objekt Speicherplatz zu und
ruft den passenden Konstruktor (Initialisierung) auf
Beispiel:
import java.util.Date;
class DatumAnzeige {
public static void main( String args[] ){
Date d1, d2;
d1 = new Date();
System.out.println(“Datum 1: “ + d1);
d2 = new Date(“April 7 1998 11:00 AM”);
System.out.println(“Datum 2: “ + d2);
}
}
Java
am IAS
© 2012, IAS
55
Klassen und Objekte in Java
Variablen (1)
Allgemein:
 Allgemeine Deklaration einer Variable:
[schlüsselwörter]
Typ/Klasse
variablenname
 Zugriff mit Hilfe der Punkt-Notation:
einObjekt.var1
//Zugriff auf var1 in einObjekt
einObjekt.v-aussen.v-innen
// verschachtelter Aufruf
Beispiel:
import java.awt.Point;
class TestPunkt {
public static void main( String args[] ) {
Point punkt = new Point ();
punkt.x = 5;
punkt.y = 12;
System.out.println(“Punkt(x/y): “ + punkt.x
+ “/” + punkt.y”);
}
}
Java
am IAS
© 2012, IAS
56
Klassen und Objekte in Java
Variablen (2)
Klassenvariablen:
 Klassenvariablen sind im Gegensatz zu „normalen“
Variablen Bestandteil der Klasse und nicht eines Objektes,
d.h. sie sind nur einmal pro Klasse vorhanden.
 Klassenvariablen werden mit dem static Schlüsselwort
definiert:
class FamilienMitglied {
static String nachname = “Mueller”;
String vorname;
}
 der Zugriff auf Klassenvariablen kann entweder über die
Klasse oder über das Objekt erfolgen:
FamilienMitglied sohn = new FamilienMitglied();
System.out.println(FamilienMitglied.nachname ); // ueber Klasse
System.out.println(sohn.nachname );
// ueber Objekt
Java
am IAS
© 2012, IAS
57
Klassen und Objekte in Java
Variablen (3)
Referenzen:
 Java kennt keine Zeiger und Zeigerarithmetik, aber
 ähnliche Möglichkeiten durch Referenzen
 Arbeiten mit Objekten bedeutet in Java hauptsächlich
Arbeiten mit Referenzen:
Beispiel:
import java.awt.Point;
class ReferenzenTest {
public static void main( String args[] ) {
Point pt1, pt2;
pt1 = new Point(100, 100);
pt2 = pt1;
pt1.x = 200;
pt1.y = 200;
System.out.println(“pt1: “ + pt1.x + “,” + pt1.y);
System.out.println(“pt2: “ + pt2.x + “,” + pt2.y);
}
}
Java
am IAS
© 2012, IAS
58
Klassen und Objekte in Java
Variablen (4)
Erklärungen zu ReferenzenTest:
pt1
1. Referenzen pt1, pt2
anlegen
pt2
2. Point-Objekt mit Wert
(100, 100) anlegen,
Referenz pt1 zeigt auf Objekt
3. Referenz pt2 zeigt auf selbes Objekt wie pt1
4. Objektwerte werden mit Hilfe von pt1 geändert
5. Werteausgabe mit Hilfe von pt1 und pt2
Java
am IAS
© 2012, IAS
Point Objekt
x: 200
y: 200
59
Klassen und Objekte in Java
Variablen (5)
Arrays:
 Arrays können beliebig viele Elemente eines Datentyps speichern
 verschiedene Datentyp-Elemente in einem Array sind nicht
möglich
 Deklaration
String[] words;
Point[] hits;
oder
String words[];
Point hits[];
 Erstellen des Array-Objekts
String[] words = new String[10];
String[] farbe = {“weiss”, “schwarz”, “rot”};
• Array kann mit new (s. words) oder mit Initialisierungswerten
(s. farbe) erstellt werden
• mit new werden die Array-Elemente automatisch initialisiert
(Initialisierungswerte (abhängig vom Datentyp): 0, false, ““)
Java
am IAS
© 2012, IAS
60
Klassen und Objekte in Java
Variablen (6)
Arrays:
 Zugriff auf Array-Elemente
String[] words = new String[10];
words[0] = “Java”;
 ein Array der Größe n hat die Indizes [0] bis [n-1]
 Zugriffe außerhalb des Arrays werden von Compiler und von der
Laufzeitumgebung erkannt, z.B. words[10] = “Error”
 die Instanzenvariable length enthält die Größe des Arrays
int laenge = words.length; // gibt 10 aus
 durch Schachtelung können mehrdimensionale Arrays
erzeugt werden:
int koord[][] = new int[5][10];
koord[0][0] = 4;
koord[4][9] = 123;
Java
am IAS
© 2012, IAS
61
Klassen und Objekte in Java
Methoden (1)
Definition:
 eine Methode besteht aus mindestens vier Teilen:
• Name der Methode
• Parameter (Argumentliste)
• Datentyp, der von der Methode zurückgegeben wird (void: kein Rückgabewert)
Signatur
• Methodenkörper
returntype methodenname(typ1 arg1, typ2 arg2, ...){
...
}
 optional können Zugriffsrechte und Ausnahmen festgelegt werden
 mit this auf das aktuelle Objekt zugegriffen werden
t = this.x;
// Zuweisung Objektvariable x
this.methode1(this); // Methodenaufruf mit this
return this;
// Rueckgabe des aktuellen Objekts
Java
am IAS
© 2012, IAS
62
Klassen und Objekte in Java
Methoden (2)
Methodenaufruf:
 Methoden werden mit Hilfe der Punkt-Notation und
Argumentliste (in Klammern) aufgerufen:
einObjekt.methode1(arg1, arg2, arg3);
 verschachtelte Methodenaufrufe sind möglich:
einObjekt.var1.methode1(arg1, arg2);
 in der Parameterliste werden primitive Datentypen als
Wert,
alle anderen als Referenz an die Methode übergeben,
d.h. wird ein referenziertes Objekt von der Methode
verändert, so bleibt die Veränderung nach Beendigung
der Methode bestehen
Java
am IAS
© 2012, IAS
63
Klassen und Objekte in Java
Methoden (3)
Beispiel:
...
class RefArgument {
int One2Zero( int arg[]) {
int count = 0;
for( int i = 0; i < arg.length; i++ ) {
if(arg[i] == 1) {
count++;
arg[i] = 0;
}}
return count;
}}
public static void main (String[] args) {
int arr[] = {1, 5, 3, 1, 1, 6, 8, 1};
int nEins;
RefArgument test = new RefArgument();
for( int i = 0; i < arr.length; i++ )
System.out.print(arr[i] + “ “);
nEins = test.One2Zero(arr);
System.out.println(“Gefundene Einsen: “ + nEins);
for( int i = 0; i < arr.length; i++ )
System.out.print(arr[i] + “ “);
}
...
Java
am IAS
© 2012, IAS
64
Klassen und Objekte in Java
Methoden (4)
Klassenmethoden:
 Klassenmethoden wirken sich (wie Klassenvariablen) auf
ganze Klassen und nicht nur auf einzelne Objekte aus
 werden dort benützt, wo Objekte nicht vorausgesetzt sind,
z.B. Klasse Math der Java-Klassenbibliothek:
float root = Math.sqrt(453.2);
 Klassenmethoden werden mit dem static Schlüsselwort
definiert:
static int max( int arg1, int arg2) {...}
 Regel: Alle Methoden, die von allgemeiner Nützlichkeit
sind und nicht auf einzelne Objekte anwendbar sind, sollten
als Klassenmethoden definiert werden.
 Frage: Kennen Sie bereits eine Klassenmethode?
 Antwort: Die main-Methode
Java
am IAS
© 2012, IAS
65
Klassen und Objekte in Java
Vergleichen von Objekten
 die meisten Operatoren sind nur auf primitive Datentypen
(int, byte, char), aber nicht auf Objekte anwendbar
 Ausnahme: == und != prüfen Objekt(un)gleichheit,
aber keine Werte(un)gleichheit
 Wertevergleich in Klasse String durch Methode equals():
Beispiel:
class EqualsTest {
public static void main(String args[]) {
String str1, str2;
str1 = “Java macht Spass!”;
str2 = str1;
System.out.println(“Gleiches Objekt? “ +
(str1 == str2));
str2 = new String(str1);
System.out.println(“Gleiches Objekt? “ +
(str1 == str2));
System.out.println(“Gleicher Wert? “ +
str1.equals(str2));
}
}
Java
am IAS
© 2012, IAS
// wahr
// falsch
// wahr
66
Klassen und Objekte in Java
Kopieren von Objekten
 mit copy() kann ein Objekt in eine Instanz derselben
Klasse kopiert werden
 im kopierten Objekt enthaltene Objekte werden nicht
mitkopiert
Point pt1, pt2, pt3;
pt1 = new Point(0, 0);
pt2 = new Point(100, 100);
pt2.copy(pt1); // alle pt1-Werte werden in pt2 kopiert
 mit clone() kann eine neue Instanz der Quellobjekt-Klasse
erzeugt und mit den Quellobjektwerten initialisiert werden
pt3 = (Point) pt2.clone();
Java
am IAS
© 2012, IAS
67
Klassen und Objekte in Java
Zusammenfassung
 Paradigma Objektorientierung:
•
•
•
•
Abstraktion
Kapselung
Modularität
Hierarchie
 Struktur eines Java-Programms:
Klassen und Pakete  Dateien und Verzeichnisse
 Aufbau einer Klasse:
objekt- und klassenbezogene Variablen und Methoden
 Arbeiten mit Objekten heißt arbeiten mit Referenzen
 Elementare Operationen auf Objekten:
Erzeugen, Vergleichen und Kopieren
Java
am IAS
© 2012, IAS
68
Kursüberblick
Zweiter Tag
Teil 1:
 Overloading, Konstruktoren, Vererbung
 Ausnahmebehandlung
Teil 2:
 Datenstreams und Dateien
Java
am IAS
© 2012, IAS
69
Overloading, Konstruktoren, Vererbung
Überladen von Methoden (1)
 Überladen von Methoden (Overloading): gleicher
Methodenname, aber unterschiedliche Argumentliste
(Anzahl und Typ)
 in Java können nur Methoden überladen werden
(Operatoren-Overloading ist nicht möglich)
 Überladen bewirkt Vereinfachung der Schnittstelle: nur ein
Methodenname muss gelernt werden, richtige Methode
wird in Abhängigkeit von Argumentliste aufgerufen
 Wichtig: Rückgabetyp kann beim Überladen nicht zur
Unterscheidung verwendet werden
Java
am IAS
© 2012, IAS
70
Overloading, Konstruktoren, Vererbung
Überladen von Methoden (2)
Beispiel - Initialisierung mit Methoden
class Rechteck1 {
int x1 = 0;
// Punktkoordinaten oben rechts
int y1 = 0;
int x2 = 0;
// Punktkoordinaten unten links
int y2 = 0;
Rechteck initRecht(int x1, int y1, int x2, int y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
return this;
}
}
Java
am IAS
Rechteck initRecht(Point obLinks, Point unRechts) {
x1 = obLinks.x;
y1 = obLinks.y;
x2 = unRechts.x;
y2 = unRechts.y;
return this;
}
© 2012, IAS
71
Overloading, Konstruktoren, Vererbung
Konstruktor (1)
 besondere Methodenart, die bei der Instanziierung einer
Klasse (new) automatisch aufgerufen wird
 Konstruktoren bestimmen die Initialisierung der Objekte
 Ablauf der Instanziierung mit new:
• Speicherplatz für Objekt reservieren
• Initialisierung der Instanzvariablen mit Defaultwerten
• Konstruktor-Aufruf
 Konstruktor-Definition:
• gleicher Name wie Klasse
• kein Rückgabewert!
 Konstruktoren können wie Methoden überladen werden
 Aufräumarbeiten können mit der finalize-Methode
veranlasst werden (Dekonstruktor)
Java
am IAS
© 2012, IAS
72
Overloading, Konstruktoren, Vererbung
Konstruktor (2)
Beispiel - Initialisierung mit Konstruktoren:
class
int
int
int
int
Rechteck {
x1 = 0;
y1 = 0;
x2 = 0;
y2 = 0;
// Punktkoordinaten oben rechts
// Punktkoordinaten unten links
Rechteck(int x1, int y1, int x2, int y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
}
Java
am IAS
Rechteck(Point obLinks, Point unRechts) {
x1 = obLinks.x;
y1 = obLinks.y;
x2 = unRechts.x;
y2 = unRechts.y;
}
© 2012, IAS
73
Overloading, Konstruktoren, Vererbung
Vererbung (1)
 ermöglicht Hierarchisierung von Klassen
 übergeordnete Superklassen vererben Variablen und
Methoden
an Subklassen, d.h. Subklassen erben von Superklassen
 in Java erben alle Klassen implizit von der Klasse Object,
welche allgemeingültige Verhaltensregeln definiert
Klassenhierarchie:
C
Java
am IAS
A
Hierarchie-Wurzel: Klasse A
(in Java Klasse Object)
B
abgeleitete Klasse B, erbt von A
D
E
© 2012, IAS
abgeleitete Klassen C, D und E
erben jeweils von B und A
74
Overloading, Konstruktoren, Vererbung
Vererbung (2)
 Vererbungsvarianten: Einfach- und Mehrfachvererbung
 Einfachvererbung: jede Klasse hat höchstens eine
Superklasse
 Mehrfachvererbung: jede Klasse kann von mehreren
Superklassen erben (in Java nicht erlaubt)
Einfachvererbung
(Baum):
Java
am IAS
Mehrfachvererbung
(Netz):
© 2012, IAS
75
Overloading, Konstruktoren, Vererbung
Vererbung (3)
Beispiel:
class Punkt {
int x;
// x-Koordinate
int y;
// y-Koordinate
void printInfoPunkt() {
System.out.println(“Punkt: “ + x + “/“ + y);
}
}
class Pixel extends Punkt {
String farbe;
// Punktfarbe
}
void printInfoPixel() {
System.out.println(“Pixel: “ + x + “/” + y);
System.out.println(“Pixelfarbe: “ + farbe”);
}
 Subklasse erbt automatisch alle Variablen und Methoden
der Superklasse
 Regel: Ableiten macht nur Sinn, wenn eine
allgemeingültige Klasse durch neue Methoden/Variablen
erweitert/verändert werden soll
Java
am IAS
© 2012, IAS
76
Overloading, Konstruktoren, Vererbung
Vererbung (4)
 Wie funktioniert ein Methodenaufruf in Java?
• zunächst in der aktuellen Klasse nach passender
Methodendefinition suchen
• falls Suche in aktueller Klasse erfolglos, Aufruf in der
Klassenhierarchie nach oben weiterreichen
 Konsequenzen:
• bereits definierte Methoden können in Subklassen ohne
Codeduplizierung wiederverwendet werden
• die Methode einer Superklasse kann in der Subklasse entweder
unverändert übernommen oder überschrieben/redefiniert
werden
 Wichtig: Überschreiben (Signatur gleich) nicht mit
Überladen (Argumentliste unterschiedlich) verwechseln!
Java
am IAS
© 2012, IAS
77
Overloading, Konstruktoren, Vererbung
Methoden überschreiben (1)
 Methoden mit identischer Signatur wie in Superklasse, aber
unterschiedliche Methodenkörper
 Warum überschreibt man Methoden?
• um geerbte Methoden vollständig zu ersetzen
• um geerbte Methoden zu erweitern
Beispiel:
class PrintKlasse {
int x = 0;
int y = 1;
void drucken() {
System.out.println(“x, y = “ + x + “ “ + y);
}
}
class PrintSubKlasse extends PrintKlasse {
int z = 3;
void drucken() { // geerbte Methode ersetzen
System.out.print(“x, y, z = “ + x + “ “ + y + “ “ + z);
}
}
Java
am IAS
© 2012, IAS
78
Overloading, Konstruktoren, Vererbung
Methoden überschreiben (2)
 das Schlüsselwort super ermöglicht den Zugriff auf die
“verdeckte” Orginalmethode in der Superklasse
Beispiel:
class PrintKlasse {
int x = 0;
int y = 1;
void drucken() {
System.out.println(“x, y = “ + x + “ “ + y);
}
}
class PrintSubKlasse extends PrintKlasse {
int z = 3;
void drucken() { // geerbte Methode erweitern
super.drucken();
System.out.print(“z = “ + z);
}
}
Java
am IAS
© 2012, IAS
79
Overloading, Konstruktoren, Vererbung
Konstruktoren überschreiben?
 Konstruktoren werden grundsätzlich nicht vererbt und
können somit auch nicht überschrieben werden
 beim Konstruktoraufruf für ein Objekt werden automatisch
alle Konstruktoren der Superklassen aufgerufen
 mit dem Schlüsselwort super wird der “richtige”
Konstruktor der Superklasse aufgerufen
Beispiel:
class BenannterPunkt extends Point{
String name;
}
Java
am IAS
BenannterPunkt(int x, int y, String name) {
super(x, y);
this.name = name;
}
© 2012, IAS
80
Overloading, Konstruktoren, Vererbung
Zugriffsrechte für Klassen
 in Java wird die Kapselung (OO-Hauptelement) mit Hilfe
von Schlüsselwörtern (modifier) verwirklicht
 für Klassen stehen zwei Zugriffsebenen zur Verfügung:
public und package
public
 mit public definierte Klassen sind für alle anderen Klassen
sichtbar
package
 ohne zusätzliche Angaben sind Klassen automatisch nur
innerhalb des gleichen Pakets sichtbar (kein packageSchlüsselwort notwendig)
Java
am IAS
© 2012, IAS
81
Overloading, Konstruktoren, Vererbung
Zugriffsrechte für Methoden und Variablen (1)
 in Java stehen für Methoden und Variablen 4
Zugriffsebenen zur Verfügung: public, package,
protected und private
 das Zugriffs-Schlüsselwort steht vor dem Methoden/Variablen-namen und wird jeweils einzeln vereinbart
public
 mit public definierte Methoden/Variablen sind für alle
anderen Klassen sichtbar, d.h. es gibt keine
Zugriffsbeschränkungen
Beispiel:
public class OffeneKlasse {
public int offenesInt;
public String offenerString;
}
Java
am IAS
public float offeneMethode() {
...
}
© 2012, IAS
82
Overloading, Konstruktoren, Vererbung
Zugriffsrechte für Methoden und Variablen (2)
package
 mit dem package-Schlüsselwort werden Klassen
in Pakete gruppiert
 falls explizit kein Zugriffsebene definiert wird gilt
automatisch die package-Schutzebene (kein packageSchlüsselwort)
 alle Methoden/Variablen dieser Ebenes sind nur innerhalb
des gleichen Pakets sichtbar
Beispiel:
package paket1;
public class PaketKlasse {
int paketInt = 2;
String paketString = “a bis z”;
}
Java
am IAS
float paketMethode() {
...
}
© 2012, IAS
83
Overloading, Konstruktoren, Vererbung
Zugriffsrechte für Methoden und Variablen (3)
protected
 nur Elemente der gleichen und davon abgeleiteter Klassen
haben Zugriff
Beispiel:
public class ProtectedKlasse {
protected int protInt = 4;
protected String pstr = “a bis z”;
protected float protectedMethod() {
...
}
}
public class GleichesPaket {
public void test() {
ProtectedKlasse pk = new ProtectedKlasse();
System.out.println(pk.pstr);
pk.protectedMethod();
}
Nicht erlaubt!
}
Java
am IAS
© 2012, IAS
84
Overloading, Konstruktoren, Vererbung
Zugriffsrechte für Methoden und Variablen (4)
private
 strengster Schutz: Methoden und Variablen nur innerhalb
der eigenen Klasse zugreifbar
 im Sinne einer umfassenden Kapselung sollten Daten
möglichst private deklariert werden
 spezielle get/set-Methoden ermöglichen den kontrollierten
Zugriff auf die private-Elemente
Beispiel:
public class Kreis {
private int x, y, radius;
public int getRadius() {
return radius;
}
public int setRadius( int value ) {
radius = value;
return radius;
}
}
Java
am IAS
© 2012, IAS
85
Overloading, Konstruktoren, Vererbung
Zugriffsrechte im Überblick
Klasse
public
für alle Klassen (auch außerhalb des
Pakets)
nur für Klassen innerhalb des Pakets
Methode/
Variable
public
für alle Klassen (auch außerhalb des
Pakets)
nur für Klassen innerhalb des Pakets
protected
private
abgeleitete Klassen und Klassen
innerhalb des Pakets
nur für eigene Klasse
Empfehlung:
• Datenelemente (Variablen) private
• Methoden protected
• get-/set-Methoden für Zugriff auf private Daten definieren
Java
am IAS
© 2012, IAS
86
Overloading, Konstruktoren, Vererbung
final-Modifier (1)
 mit dem final-Schlüsselwort können zusätzl. Einschränkungen
definiert werden, die Compiler-Optimierungen ermöglichen
Klassen
 mit final deklarierte Klassen können nicht abgeleitet werden
public final class FinalKlasse1 { ... }
Methoden
 final-Methoden können in Subklassen nicht überschrieben
werden
public class FinalKlasse2 {
public final void finalMethode() {
...
}
}
 alle Methoden in einer final-Klasse sind final
 alle private-Methoden sind implizit final
Java
am IAS
© 2012, IAS
87
Overloading, Konstruktoren, Vererbung
final-Modifier (2)
Variablen
 mit final werden in Java Konstanten deklariert
public class FinalKlasse3 {
public final int CONSTINT = 243;
public final String CSTR = “Kaffee”;
}
 der konstante Wert wird während der Deklaration
zugewiesen
 lokale Variablen können nicht als final deklariert werden
while( summe <= 10 ) {
...
final int LOCALINT;
...
}
Java
am IAS
Nicht erlaubt!
© 2012, IAS
88
Overloading, Konstruktoren, Vererbung
abstract-Modifier
 abstrakte Klassen sind ein Design-Element: mit abstract
gekennzeichnete Klassen können nicht instanziiert werden
 in einer abstrakten Klasse werden Methoden ohne
Implementierung (Methodenkörper) mit abstract
gekennzeichnet
Beispiel:
public abstract class AbstrakteKlasse {
int i;
public void tuWas() {
...
}
}
public abstract void absMethode();
Object a = new AbstrakteKlasse();
Nicht erlaubt!
Java
am IAS
© 2012, IAS
89
Overloading, Konstruktoren, Vererbung
Schnittstellen (1)
Problem: “Tierhierarchie”
Tier
Säugetier
Merkmale:
+ lebende Jungen
+ Fell
Vogel
+ legen Eier
+ Schnabel
Wohin gehört das Schnabeltier (Fell & Schnabel)?
Ziel:
gemeinsames Verhalten verwenden, ohne
Codeduplizierung
Lösung:
a) Mehrfachvererbung: in Java nicht erlaubt
b) Schnittstellen
Java
am IAS
© 2012, IAS
90
Overloading, Konstruktoren, Vererbung
Schnittstellen (2)
 Schnittstelle: Sammlung von abstrakten
Methodendeklarationen
und Konstanten ohne Methodenimplementierungen
und Instanzvariablen
Definition
 Deklaration mit Schlüsselwort interface
 Schnittstellenmethoden sollten als public abstract und
Konstanten als public static final deklariert sein
 Schnittstellen gehören zu Paketen und können andere
Pakete importieren
 Schnittstellen können mit extends in Hierarchien
organisiert werden
public interface Iface {
public static final int incr = 10;
public static final long maxNum = 1000000;
public abstract void doIt();
}
Java
am IAS
© 2012, IAS
91
Overloading, Konstruktoren, Vererbung
Schnittstellen (3)
Anwendung
 Schnittstellen werden durch das Schlüsselwort implements
in eine Klassendefinition eingebunden
 alle in der Schnittstelle deklarierten Methoden müssen von
der einbindenden Klasse implementiert werden
 eine Klasse darf mehrere Schnittstellen implementieren
 Regel: Schnittstellen können mit wenigen Ausnahmen
überall dort verwendet werden, wo auch Klassen verwendet
werden
Beispiel:
public interface Fruchtartig {
public abstract void verfallen();
public abstract void auspressen();
}
public class Frucht implements Fruchtartig {
private Color farbe;
public void verfallen() { ... }
public void auspressen() { ... }
}
Java
am IAS
© 2012, IAS
92
Kursüberblick
Zweiter Tag
Teil 1:
 Overloading, Konstruktoren, Vererbung
 Ausnahmebehandlung
Teil 2:
 Datenstreams und Dateien
Java
am IAS
© 2012, IAS
93
Ausnahmebehandlung
Ausnahmefälle (1)
 Design und Implementierung von Klassen und Methoden
beschreiben normalen Ablauf, nicht jedoch den Ablauf in
“Ausnahmefällen”
 Java bietet die Möglichkeit, Ausnahmefälle zu deklarieren und
zu behandeln, d.h. ungewöhnliche Situationen werden
handhabbar, ohne den normalen Quellcode aufzubrechen
 Ausnahmefälle sind Objekte, die in einer Klassenhierarchie
organisiert sind
 Java kennt drei Arten von Ausnahmefällen, die alle von der
Superklasse Throwable abgeleitet sind:
• Ausnahmen (Exception): ClassNotFound, FileNotFound
• Laufzeitausnahmen (RuntimeException):
IndexOutOfBounds
• Fehler (Error): OutOfMemory, StackOverflow
Java
am IAS
© 2012, IAS
94
Ausnahmebehandlung
Ausnahmefälle (2)
Ausnahmefälle deklarieren
 Ausnahmefälle, die innerhalb einer Klasse oder Methode
auftreten können, werden mit dem throws-Schlüsselwort
deklariert
public class AusnahmeKlasse {
public void ausnahmeMethode1() throws AusnameFall1 {
...
}
 Fehler und Laufzeitausnahmen müssen nicht deklariert
werden
 Wenn in einer Methode Ausnahmen auftreten können, müssen
diese a) potentiellen Aufrufern mit der throws-Deklaration
explizit bekanntgegeben werden oder b) von der Methode
selbst gehandhabt werden
Java
am IAS
© 2012, IAS
95
Ausnahmebehandlung
Ausnahmefälle (3)
Ausnahmen handhaben (Exception Handling)
 Ausnahmefälle werden mit den try/catch-Anweisungen
gehandhabt
public void methode2() {
AusnahmeKlasse aKlasse = new AusnahmeKlasse();
try {
// ausnahmeträchtiger Code
aKlasse.ausnahmeMethode1();
} catch ( AusnahmeFall1 ) {
...
}
}
 eingetretene Ausnahmen werden in der MethodenAufrufhierarchie nach oben gereicht, bis sie a) behandelt
werden oder b) das Programm mit einer Fehlermeldung
abgebrochen wird
Java
am IAS
© 2012, IAS
96
Ausnahmebehandlung
Ausnahmefälle (4)
Ausnahmen auswerfen
 mit Hilfe der throw-Anweisung werden Ausnahmen
“ausgeworfen”
public class AusnahmeKlasse {
public void ausnahmeMethode1() throws AusnahmeFall1 {
// normaler Code
if( ungewoehnlicherVorfall() ) {
throw new AusnahmeFall1();
// hier wird die Ausfuehrung abgebrochen
}
}
}
 tritt eine Ausnahme ein, so werden alle Anweisungen hinter
der throw-Anweisung ignoriert
Java
am IAS
© 2012, IAS
97
OO-Konzepte & Ausnahmebehandlung
Zusammenfassung
 Überladen von Methoden
 Konstruktoren
 Vererbung
 Überschreiben von Methoden/Konstruktoren
 Zugriffsrechte für Klassen, Methoden und Variablen
 final-Modifier
 abstrakte Klassen und Methoden
 Schnittstellen
 Behandlung von Ausnahmen
Java
am IAS
© 2012, IAS
98
Kursüberblick
Zweiter Tag
Teil 1:
 Overloading, Konstruktoren, Vererbung
 Ausnahmebehandlung
Teil 2:
 Datenstreams und Dateien
Java
am IAS
© 2012, IAS
99
Datenstreams und Dateien
Datenstreams




Informationen aus einer Quelle einlesen
Informationen an ein Ziel ausgeben
z.B. Datei, Bildschirm
allgemeiner Ablauf:
Lesen
Einen Stream öffnen
Solange noch Informationen vorhanden
Information lesen
Stream schließen
Schreiben
Einen Stream öffnen
Solange noch Informationen vorhanden
Information schreiben
Stream schließen
Java
am IAS
© 2012, IAS
100
Datenstreams und Dateien
Datenstreams
 von Quelle/Ziel muss nur der Name bekannt sein
 Package java.io
 Basis: abstrakte Klassen
JDK 1.0 (8bit)
InputStream
OutputStream
seit JDK 1.1 (16 bit)
Reader
Writer
notwendig wegen 16bit Unicode
 höhere Interpretationsebenen darauf aufbauend möglich
(z.B. Serialisation 1.1. --> 1.0)
 Fehlerbehandlung: IOExceptions
Unterklasse von Exception
behandelt alle bei Datenstreams möglichen Ein- und
Ausgabefehler
Java
am IAS
© 2012, IAS
101
Datenstreams und Dateien
Datenstreams
 Trennung der Klassenhierarchie in
- Eingabe-(Input-)Streams
und
- Ausgabe-(Output-)
Streams
 Trennung der Klassenhierarchie in
- Charakter-Streams
(Zeichen) und
- Byte-Streams
(Binärdaten)
Java
am IAS
© 2012, IAS
102
Datenstreams und Dateien
Überblick Zeichen-Streams (Character Streams)
BufferedReader
LineNumberReader
CharArrayReader
InputStreamReader
FileReader
FilterReader
PushbackReader
Reader
PipedReader
StringReader
Lesen/Schreiben
Java
am IAS
Daten verarbeiten
© 2012, IAS
103
Datenstreams und Dateien
Überblick Zeichen-Streams (Character Streams) (Forts.)
BufferedWriter
CharArrayWriter
OutputStreamWriter
Writer
FileWriter
FilterWriter
PipedWriter
StringWriter
PrintWriter
Lesen/Schreiben
Java
am IAS
Daten verarbeiten
© 2012, IAS
104
Datenstreams und Dateien
Überblick Byte-Streams
FileInputStream
InputStream
PipedInputStream
LineNumberInputStream
FilterInputStream
DataInputStream
ByteArrayInputStream
BufferedInputStream
SequenceInputStream
PushbackInputStream
StringBuffferInputStream
ObjectInputStream
FileOutputStream
OutputStream
PipedOutputStream
PrintStream
FilterOutputStream
DataOutputStream
ByteArrayOutputStream
BufferedOutputStream
ObjectOutputStream
Java
am IAS
© 2012, IAS
105
Datenstreams und Dateien
EingabeStreams (InputStream) und Leser (Reader)
 Grundlage aller Eingabeoperationen von Java
 InputStream (Reader) definiert die Grundlagen für das
Lesen eines Byte-Streams (Zeichen-Datenstream) von
einer Quelle.
 Identität der Quelle und Art der Erstellung und Beförderung
von Bytes (Zeichen) nicht relevant
 Reader und seine Unterklassen sind weitgehend analog der
Klasse InputStream, sie benutzen nur Zeichen anstelle
Bytes.
 Alle auf InputStream (Reader) aufbauende DatenstreamKlassen besitzen die auf den folgenden drei Folien
vorgestellten Methoden.
Java
am IAS
© 2012, IAS
106
Datenstreams und Dateien
EingabeStreams und Leser (Forts.)
Methode read(): Liest Bytes (Zeichen) von einer Quelle
 wartet, bis alle angeforderten Eingaben zur Verfügung stehen
--> Threads
notw. da abstrakte
 import java.io.* notwendig
Klasse
Beispiel (versucht, den gesamten Puffer zu füllen)
InputStream s = getAnInputStream();
byte[]
bbuffer = new byte[256];
// beliebige Größe
if (s.read(bbuffer) != bbuffer.length)
System.out.println(“Weniger erhalten als erwartet.”);
 read() liefert Anzahl der gelesen Byte (Zeichen) zurück
bzw. -1 zurück, wenn der Eingabestring zu Ende oder leer ist.
 weitere read() Methoden, um einen Bereich des Puffers
zu füllen oder einzelne Bytes (Zeichen) einzulesen
Java
am IAS
© 2012, IAS
107
Datenstreams und Dateien
EingabeStreams und Leser (Forts.)
 skip(anz): überspringt anz Bytes (Zeichen) im Datenstream
 available(): gibt an, wieviele Bytes (Zeichen) ein
Datenstream momentan umfasst.
Antwort nicht immer möglich.
 ready(): gibt an, ob weitere Bytes (Zeichen) bereitstehen
Antwort nicht immer möglich.
 mark() und reset(): Markierung einer Position im
Datenstream und Zurücksetzen auf die Position, um die Bytes
(Zeichen) erneut einzulesen
Wird nicht von allen Datenstreams unterstützt
--> Methode markSupported(): prüft, ob Markierung möglich
Java
am IAS
© 2012, IAS
108
Datenstreams und Dateien
EingabeStreams und Leser (Forts.)
 Methode close(): Schließen des Datenstreams und Freigabe
der Ressourcen
Beispiel
Reader
r = makeAReader();
if (r != null) {
try {
...
} finally {
r.close();
}
}
// r benutzen
Durch Verwendung von finally wird der Datenstream auf
jeden Fall geschlossen. Durch Prüfung auf null wird der
Misserfolg bei der Erzeugung des Datenstreams abgefangen.
Java
am IAS
© 2012, IAS
109
Datenstreams und Dateien
ByteArrayInputStream und CharArrayReader
 lesen Byte-(Zeichen-)Arrays aus dem Speicher
Beispiel
byte[] bbuffer = new byte[256];
fillBuffer(bbuffer);
// Puffer (Datenquelle)
// irgendwie füllen
InputStream s = new ByteArrayInputStream(bbuffer);
// Erstellen(!) eines Streams
StringBufferInputStream und StringReader
 analog ByteArrayInputStream bzw. CharArrayReader, nur
dass Zeichenketten statt Byte-(Zeichen-)Arrays verwendet
werden.
PipedInputStream und PipedReader
 zweiwegige Kommunikation zwischen Threads
Java
am IAS
© 2012, IAS
110
Datenstreams und Dateien
PushbackInputStream und PushbackReader
 Parser: einzelne Bytes (Zeichen) werden zurückgeschrieben
ObjectInputStream
 Serilisation: Umwandlung eines Objektes in einen
Datenstream (zusammen mit ObjectOutputStream)
FileInputStream und FileReader
 Datenstream aus einer Datei
Beispiel
Reader r = new FileReader(new File(“/Pfad/datei.ext“));
 FileReader ist triviale Unterklasse der Klasse
InputStreamReader:
kapselt beliebigen Eingabestream und wandelt ihn in einen
Zeichenstream um
Java
am IAS
© 2012, IAS
111
Datenstreams und Dateien
SequenceInputStream
 ermöglicht die Bildung zusammengesetzter Datenstreams
Beispiel
InputStream s1 = new FileInputStream(“dat1.ext“));
InputStream s2 = new FileInputStream(“dat2.ext“));
InputStream s
= new SequenceInputStream(s1, s2);
 Mit read() wird nacheinander aus jedem beteiligten Stream
gelesen.
 Wird eingesetzt bei Methoden, die nur einen InputStream
erwarten.
Java
am IAS
© 2012, IAS
112
Datenstreams und Dateien
FilterInputStream und FilterReader
 zur Verarbeitung der durchfließenden Bytes (Zeichen)
 besitzen Unterklassen für bestimmte Verarbeitungen
 können verschachtelt werden
Beispiel
InputStream
FilterInputStream
s = getInputStream();
s1 = new FilterInputStream(s)
Bei einer Leseoperation auf s1 wird die Anfrage an s
übergeben.
 FilterReader ist eine abstrakte Klasse!
 Zwei Filtertypen (Stream/Reader) lassen sich nicht mischen.
Java
am IAS
© 2012, IAS
113
Datenstreams und Dateien
BufferedInputStream und BufferedReader
 verwenden ein gepuffertes Byte-(Zeichen-)Array
 effizient, Vorauslesen von Daten möglich
Beispiel (Gepufferter FileReader)
Reader r = new BufferedReader(new FileReader(“dat.ext“));
 Möglichkeit, mit readLine() Zeichenzeilen zu lesen (mit ‘\r‘,
‘\n‘ oder ‘\r\n‘ abgeschlossen):
BufferedReader
String
Java
am IAS
r = new BufferedReader(new
FileReader(“dat.ext“));
line = r.readLine; // Nächste Zeile
// einlesen
© 2012, IAS
114
Datenstreams und Dateien
DataInputStream
 besitzt Methoden für komplexere Datenstreams und zum
Lesen primitiver Datentypen
void
boolean
int
readFully(byte[] bbuffer) throws IOException;
readBoolean() throws IOException;
readInt() throws IOException;
String
readLine() throws IOException; // Zeilen lesen
...
 EOFException, wenn das Ende eines Streams erreicht wird:
DataInputStream s = new DataInputStream(getAnInpStream());
try {
while (true) {
byte b = (byte) s.readByte();
... // b verarbeiten
}
} catch (EOFException e) {
... // Ende erreicht
}
Java
am IAS
© 2012, IAS
115
Datenstreams und Dateien
LineNumberInputStream und LineNumberReader
 ermöglichen eine Zeilennummerierung
Beispiel
LineNumberReader
String
r = new LineNumberReader(new
FileReader(“dat.ext“));
line;
while ((line = r.readLine()) != null) {
...
// Zeilen verarbeiten
System.out.println(r.getLineNumber() + “ Zeilen.“);
}
 Beim Verschachteln von Streams auf die Reihenfolge achten.
Filterstreams und Puffer immer in die Mitte der Kette.
Beispiel
new DataInputStream(new LineNumberInputStream(
new BufferedInputStream(new FileInputStream(“dat.ext“))));
Java
am IAS
© 2012, IAS
116
Datenstreams und Dateien
AusgabeStreams (OutputStream) und Writer
 Zu (fast) jedem InputStream bzw. Reader existiert ein
passender OutputStream bzw. Writer.
 OutputStream (Writer) sind abstrakte Klassen, welche die
Grundlagen der Unterklassen für das Schreiben eines ByteStreams (Zeichen-Datenstream) in ein Ziel definieren.
 Writer und seine Unterklassen sind analog der Klasse
OutputStream, sie benutzen nur Zeichen anstelle Bytes.
 Alle auf OutputStream (Writer) aufbauende DatenstreamKlassen besitzen die auf der folgenden Folie vorgestellten
Methoden.
Java
am IAS
© 2012, IAS
117
Datenstreams und Dateien
Ausgabestreams (OutputStream) und Writer (Forts.)
Methode write(): Schreibt Bytes (Zeichen) in ein Ziel
Beispiel
OutputStream s = getAnOutputStream();
byte[]
bbuffer = new byte[256];
// beliebige Größe
fill(bbuffer);
// Auszugebende Daten
s.write(bbuffer);
 weitere write() Methoden, um einen Bereich des Puffers
auszugeben oder einzelne Bytes (Zeichen) zu schreiben
 Methode flush(): leert den Ausgabestream und schreibt alle
gepufferten Daten aus
 Methode close(): schließt den Datenstream
Java
am IAS
© 2012, IAS
118
Datenstreams und Dateien
ByteArrayOutputStream und CharArrayWriter
 schreibt Byte-(Zeichen-)Arrays in den Speicher
Beispiel
Writer w = new CharArrayWriter();
w.write(‘\n‘);
 size() gibt aktuelle Anzahl Bytes (Zeichen) im
geschriebenen Byte-(Zeichen-) Array an.
StringWriter
 analog CharArrayWriter, nur dass Zeichenketten statt
Zeichen-Arrays verwendet werden.
PipedOutputStream und PipedWriter
 zweiwegige Kommunikation zwischen Threads
Java
am IAS
© 2012, IAS
119
Datenstreams und Dateien
FileOutputStream und FileWriter
 Datenstream in eine Datei
Beispiel
import java.io.*;
public class FileWriterBeispiel {
public static void main(String[] args) {
String str = "Hallo Welt.\r\n";
FileWriter fw;
try {
fw = new FileWriter(“welt.txt");
fw.write(str);
fw.close();
} catch (IOException e) {
System.out.println("Fehler beim Dteierstellen");
}
}
}
Java
am IAS
© 2012, IAS
120
Datenstreams und Dateien
FilterOutputStream und FilterWriter
 zur Verarbeitung der durchfließenden Bytes (Zeichen)
 können verschachtelt werden
BufferedOutputStream und BufferedWriter
 verwenden ein gepuffertes Byte-(Zeichen-)Array
Writer w = new BufferedWriter(new FileWriter(“dat.ext“));
 Möglichkeit, mit newLine() systemabhängige Zeichenzeilen
zu schreiben (z.B. ‘\r‘, ‘\n‘ oder ‘\r\n‘ als Zeilenabschluss).
DataOutputStream
 besitzt Methoden für komplexere Datenstreams und zum
Schreiben primitiver Datentypen
void
void
writeBoolean(boolean b) throws IOException;
writeInt(int i) throws IOException;
void
writeChars(String s) throws IOException;
...
Java
am IAS
© 2012, IAS
121
Datenstreams und Dateien
PrintStream und PrintWriter
 für formatierte Ausgabe
 häufigster Einsatz: Ausdruck in die Standardausgabe
System.out.println(...); // Instanz von PrintStream in der
// Variablen out der Klasse
// System
 löst keine IOException aus
 implementiert flush(), close(), write()
 implementiert verschiedene Methoden zur Ausgabe primitiver
Datentypen und Zeichenketten:
void print(String s);
void print(Char c);
void print(int i);
...
Java
am IAS
© 2012, IAS
122
Datenstreams und Dateien
Dateien verarbeiten
 z.B. Öffnen, zeilenweises Lesen, Ausgeben in andere Datei
DataInput
DataOut
String
aDI = new DataInputStream(
new FileInputStream(“in“));
aDO = new DataOutputStream(
new FileOutputStream(“out“));
line;
while ((line = aDI.readLine()) != null) {
StringBuffer modifiedLine = new StringBuffer(line);
...
// Zeile modifiedLine verarbeiten
aDO.writeBytes(modifiedLine.toString());
}
aDI.close(),
aDO.close();
 Einbettung in Methode notwendig, die IOException auslöst.
Java
am IAS
© 2012, IAS
123
Datenstreams und Dateien
Klasse file
 Abstraktion eines Dateinames
 File-Objekt kann für eine Datei oder ein Verzeichnis stehen
 Konstruktor:
public File(String pathname)
// Dateiname inkl. Pfad
public File(String parent, String child)
// Pfad und Dateiname getrennt
Beispiel
new File("c:\\temp\\bsp.txt")
 Methoden zum Zugriff auf Bestandteile des Dateinames:
• getName(): Name der Datei bzw. des Verzeichnisses ohne Pfad
• getPath(): kompletter Name inklusive Verzeichnisinfo
• getParent(): Name des Vaterverzeichnisses
...
 Methoden zum Zugriff auf Informationen über die Datei:
• lastModified(): Zeitpunkt der letzten Änderung
• isDirectory(), isFile(): zur Unterscheidung Datei/Verzeichn.
• canWrite(): Schreibzugriff möglich?
...
Java
am IAS
© 2012, IAS
124
Datenstreams und Dateien
Zugriff auf Verzeichnisse
 weitere Methode der Klasse File, falls das Objekt ein
Verzeichnis ist
• list(): Verzeichnisinhalt (Ergebnis vom Typ String[])
• mkdir(): Unterverzeichnis erstellen
...
 Methoden um Verzeichnisse und Dateien zu Löschen oder
umzubennen:
• renameTo(File dest): Umbenennen einer Datei
• delete(): Löschen einer Datei/eines Verzeichnisses
...
Java
am IAS
© 2012, IAS
125
Datenstreams und Dateien
Ausgabe verschiedener Dateiund Verzeichnisinformationen
import java.io.*;
import java.util.*;
public class FileTest {
public static void main(String[] args) {
File f = new File("TestFile.java");
TestFile.printFileInfo(f);
f = new File("..");
TestFile.printFileInfo(f);
}
}
Java
am IAS
static void printFileInfo(File f) {
System.out.println("Name= "+f.getName());
System.out.println("Path= "+f.getPath());
System.out.println("Parent= "+f.getParent());
System.out.println("exists= "+f.exists());
System.out.println("canWrite= "+f.canWrite());
System.out.println("isFile= "+f.isFile());
System.out.println("isDirectory= "+f.isDirectory());
if (f.isDirectory()) {
String fils[] = f.list();
for (int i=0; i<fils.length; ++i) {
System.out.println(" "+fils[i]);
}
}
System.out.println(
"lastModified= "+(new Date(f.lastModified())));
System.out.println("length= "+f.length());
System.out.println("");
}
© 2012, IAS
126
Kursüberblick
Vierter Tag
Teil 1:
 Applet-Grundlagen
Teil 2:
 Elemente des AWT
Java
am IAS
© 2012, IAS
127
Applet-Grundlagen
Applet contra Applikation
 Applikation
• eigenständiges Programm
• keine Beschränkungen
 Applet
• Einbettung in HTML-Seite, Ausführung im Browser
• kein Zugriff auf Client-Dateisystem
• keine Kommunikation mit anderen
Netzwerk-Servern
• keine Ausführung anderer Programme
auf dem Client-System
“Sandbox”
 Applikation und Applet sind nicht unvereinbar - ein JavaProgramm kann gleichzeitig Applikation und Applet sein
Java
am IAS
© 2012, IAS
128
Applet-Grundlagen
Applet-Erstellung
 Applets sind immer eine Subklasse von
java.applet.Applet
 die Applet Superklasse ist Teil der AWT-Hierarchie, d.h.
Applets können auf graphische Oberflächenelemente und
Ereignisbehandlung zurückgreifen
public class MeinApplet extends java.applet.Applet {
...
}
 Applets benötigen keine main()-Methode
 die Applet-Klasse muss public deklariert werden, alle
anderen Sub- und Hilfsklassen können beliebige
Zugriffsrechte vereinbaren
Java
am IAS
© 2012, IAS
129
Applet-Grundlagen
Applet-Methoden (1)
 der Lebenszyklus eines Applets besteht aus verschiedenen
Aktivitäten, die jeweils durch eine eigene Methode
repräsentiert sind: Initialisieren, Starten, Stoppen,
Zerstören und Anzeigen
Initialisieren
 Vorgang, bei dem das Applet geladen wird
 definiert grundlegendes Aussehen/Verhalten (z.B. Lesen
von Parametern, Erstellen von Hilfsobjekten, Laden von
Bildern)
 init()-Methode:
public void init() {
...
// Initialisierungaktivitaeten
}
Java
am IAS
© 2012, IAS
130
Applet-Grundlagen
Applet-Methoden (2)
Starten
 erfolgt nach der Initialisierung
 jedes Applet wird nur einmal initialisiert, kann jedoch
mehrfach gestartet werden
 start()-Methode:
public void start() {
...
}
Stoppen
 Vorgang, wenn Benutzer Seite verlässt oder Applet manuell
gestoppt wird
 stop()-Methode:
public void stop() {
...
}
Java
am IAS
© 2012, IAS
131
Applet-Grundlagen
Applet-Methoden (3)
Zerstören
 Aufräumen (z.B. Resourcen freigeben), wenn Applet oder
Browser beendet wird
 destroy()-Methode
public void destroy() {
...
}
Zeichnen
 bestimmt, was und wie auf den Bildschirm gezeichnet wird
 wird im Applet-Lebenszyklus sehr häufig aufgerufen
 paint()-Methode
public void paint(Graphics g) {
...
}
 benötigt Argument: Objekt der Klasse java.awt.Graphics
Java
am IAS
© 2012, IAS
132
Applet-Grundlagen
Graphiken (1)
 Graphikoperationen sind in Java meistens Methoden der
java.awt.Graphics-Klasse
 jedes Applet verfügt über ein Koodinatensystem
 die Koordinaten werden in Pixel (Integerwerte) angegeben
Ursprung
(0,0)
X
(10,10)
(30,20)
Y
Java
am IAS
© 2012, IAS
133
Applet-Grundlagen
Graphiken (2)
 Linien werden mit drawLine() gezeichnet:
g.drawLine( x1, y1, x2, y2 );
Anfangspunkt
Endpunkt
 Rechtecke werden mit drawRect() oder fillRect()
gezeichnet:
g.drawRect( x1, y1, dx, dy );
Ausdehnung
 Polygone werden mit drawPolygon() oder fillPolygon()
gezeichnet:
int x[] = { x1, x2, x3, x4 };
int y[] = { y1, y2, y3, y4 };
int punkte = x.length;
g.drawPolygon( x, y, punkte );
Java
am IAS
© 2012, IAS
134
Applet-Grundlagen
Graphiken (3)
 Polygone werden automatisch geschlossen. Für offene
Polygone steht die Methode drawPolyline() zur Verfügung:
int x[] = { x1, x2, x3, x4 };
int y[] = { y1, y2, y3, y4 };
int punkte = x.length;
g.drawPolyline( x, y, punkte );
 Ovale werden mit drawOval() oder fillOval() gezeichnet:
g.drawOval( x1, y1, dx, dy );
 Bögen werden mit drawArc() oder fillArc() gezeichnet:
g.drawArc( x1, y1, dx, dy, start, grad );
umgebendes Rechteck
Java
am IAS
Startwinkel
© 2012, IAS
überstrichener Winkel
+
135
Applet-Grundlagen
Graphiken (4)
 mit copyArea() wird ein rechteckiger Bereich in eine
andere Position (transx, transy) kopiert
g.copyArea( x1, y1, dx, dy, transx, transy );
 mit clearRect() wird ein Bereich auf die aktuelle
Hintergrundfarbe gesetzt
g.clearRect( x1, y1, dx, dy );
 mit Hilfe der size()-Methode wird das gesamte Applet
gelöscht
g.clearRect( 0, 0, size().width, size().height );
Java
am IAS
© 2012, IAS
136
Applet-Grundlagen
Graphiken (5)
Beispiel:
// Graphik-Beispiel
import java.awt.*;
public class Grafik extends java.applet.Applet {
public void paint( Graphics g ) {
g.drawLine(80, 20, 80, 140);
g.drawLine(20, 80, 140, 80);
g.drawRect(40, 70, 20, 20);
g.drawRect(100, 70, 20, 20);
g.fillOval(70, 70, 20, 20);
g.drawOval(50, 50, 60, 60);
g.drawArc(20, 20, 120, 120, 90, 90);
g.drawArc(20, 20, 120, 120, 0, -90);
}
}
Java
am IAS
© 2012, IAS
137
Applet-Grundlagen
Graphiken (6)
Beispiel (Forts.):
Java
am IAS
© 2012, IAS
138
Applet-Grundlagen
Text & Schrift (1)
 im Zusammenhang mit Text und Schriften sind zwei
Klassen wichtig:
• java.awt.Font bestimmt Schriftart, Stil, Punktgröße
• java.awt.FontMetrics zusätzliche Informationen über die
aktuelle Schriftart
 neue Schriften werden vor der Benutzung instanziiert:
Font f = new Font(“TimesRoman”, Font.BOLD, 24);
Schriftart
Fontstil
Schriftgröße
“Courier”
Font.PLAIN
(in Punkten)
“Helvetica” Font.ITALIC
 prinzipiell können alle auf einem System installierten
Schriften verwendet werden, Standardschriften sind jedoch
vorzuziehen
Java
am IAS
© 2012, IAS
139
Applet-Grundlagen
Text & Schrift (2)
 mit drawString() bzw. drawChar() werden einzelne
Strings und Zeichen ausgegeben
Beispiel:
public void paint( Graphics g ) {
Font f = new Font(“TimesRoman”, Font.BOLD, 32);
g.setFont(f);
g.drawString(“Java am IAS”, 40, 40);
}
 die Klasse FontMetrics liefert spezifische Informationen
über die aktuelle Schriftart
•
•
•
•
Java
am IAS
stringWidth(String): volle Breite des Strings in Pixel
charWidth(): Breite eines bestimmten Zeichens
getLeading(): “Freiraum” zwischen zwei Zeilen
getHeight(): Gesamthöhe der Schriftart
© 2012, IAS
140
Applet-Grundlagen
Text & Schrift (3)
Beispiel
// Zentrieren eines Strings im Applet
import java.awt.*;
public class Zentriert extends java.applet.Applet {
public void paint( Graphics g ) {
Font f = new Font(“TimesRoman”, Font.PLAIN, 32);
FontMetrics fm = getFontMetrics(f);
g.setFont(f);
String s = “Java im Zentrum!”;
int xstart = (getSize().width - fm.stringWidth(s))/2;
int ystart = getSize().height / 2;
g.drawString( s, xstart, ystart );
}
Java
am IAS
}
© 2012, IAS
141
Applet-Grundlagen
Farben (1)
Java Farbmodell
 die Klasse java.awt.Color bietet Unterstützung bei der
Arbeit mit Farben
 das Farbmodell in Java verwendet 24-Bit-Farben, wobei jede
Farbe eine Kombination aus Rot-, Grün- und Blauwerten ist, z.B.
• Weiß:
• Blau:
(255, 255, 255)
(0, 0, 255)
 das Farbmodell wird auf die Systemmöglichkeiten abgebildet
 zur Arbeitserleichterung ist ein Set von Standardfarben
vordefiniert:
• Color.white
• Color.black
• ...
 eigene Farben können jederzeit definiert werden:
Color meineFarbe = new Color( 7, 242, 128 );
Java
am IAS
© 2012, IAS
142
Applet-Grundlagen
Farben (2)
Farben verwenden
 eine neue Farbe wird vor der Benutzung für
Text/Zeichnungen eingerichtet
g.setColor( Color.green );
 die Hinter- und Vordergrundfarbe für ein Applet kann
eingestellt werden
setBackground( Color.green );
setForeground( Color.white );
 mit entsprechenden get-Methoden kann die aktuelle Farbe
sowie die Hinter- und Vordergrundfarbe abgefragt werden
getBackground();
getForeground();
Java
am IAS
© 2012, IAS
143
Applet-Grundlagen
Bilder (1)
 mit den Methoden der Klasse java.awt.Image können
Bilder geladen und in einem Applet angezeigt werden
Bilder laden
 mit getImage() wird ein Bild als Image-Objekt geladen
Image img = getImage( new
URL(“http://www.serv.de/files/imi01.gif”));
 um absolute Pfadangaben zu vermeiden kann
getDocumentBase() oder getCodeBase() verwendet
werden
Image img = getImage( getDocumentBase(),
“files/imi01.gif”);
 Java unterstützt z. Zt. nur Bilder im GIF oder JPEG Format
Java
am IAS
© 2012, IAS
144
Applet-Grundlagen
Bilder (2)
Bilder zeichnen
 die Ausgabe des Bildes im Applet erfolgt mit der
drawImage()-Methode
g.drawImage( img, 20, 20, this );
Bildpunkt links oben
 durch zusätzliche Angabe einer gewünschten Breite und
Höhe nach der Angabe des linken oberen Bildpunktes kann
eine Skalierung/Verzerrung erreicht werden
 die Orginaldimension des Bildes wird mit getWidth() und
getHeight() ermittelt
int bildBreite = img.getWidth(this);
int bildHoehe = img.getHeight(this);
Java
am IAS
© 2012, IAS
145
Applet-Grundlagen
Bilder (3)
Beispiel:
// Text und Bilder
import java.awt.*;
public class IASJava extends java.applet.Applet {
Image logo;
public void init() {
logo = getImage( getCodeBase(), "ias.gif");
setBackground( Color.white );
}
}
Java
am IAS
public void paint( Graphics g ) {
g.setColor( Color.red );
Font f = new Font( "TimesRoman", Font.BOLD, 36 );
g.setFont(f);
g.drawString( "Java am IAS", 20, 40 );
int iwidth = logo.getWidth( this );
int iheight = logo.getHeight( this );
g.drawImage( logo, 40, 60, iwidth, iheight, this );
}
© 2012, IAS
146
Applet-Grundlagen
Bilder (4)
Beispiel (Forts.)
Java
am IAS
© 2012, IAS
147
Applet-Grundlagen
Ereignisse & Interaktivität (1)
 Ereignisse sind eine wichtige Kommunikationsform in der
Computerwelt
 für Java-Programme sind Ereignisse interessant, die vom
Benutzer oder System verursacht werden:
•
•
•
•
•
Mausklicks
Mausbewegungen
Tastaturanschläge
Ereignisse der Benutzeroberfläche
Fensterereignisse
 Java unterstützt z.Zt. in der AWT zwei verschiedene
Ereignismodelle:
• JDK 1.02
• seit JDK 1.1 “Event-Listener-Konzept”
Java
am IAS
© 2012, IAS
148
Applet-Grundlagen
Ereignisse & Interaktivität (2)
JDK 1.02
 alle Ereignisse werden in einer einzigen handleEvent()Methode behandelt
Applet
Ereignis:
Maustaste
gedrückt
handleEvent()
mouseDown()
Ereignis:
Taste
gedrückt
keyDown()
weiterleiten
Java
am IAS
© 2012, IAS
149
Applet-Grundlagen
Ereignisse & Interaktivität (3)
ab JDK 1.1
Applet
init()
Fensterereignis
... initialize applet
... register mouse
listener
... initialize button
... register buttonaction listener
Mausereignis
Registriert
mouse listener
Tastenereignis
Registriert
Schaltflächenereignis
actions listener
Java
am IAS
© 2012, IAS
150
Applet-Grundlagen
JDK 1.1 - Ereignismodell (1)
Das Verwenden von Ereignissen in einem Applet erfolgt
nach festgelegten Spielregeln:
 Schritt 1: entscheiden, welche Ereignisse für das Applet
wichtig
sind und zugehörige Listener-Typen herausfinden
 Schritt 2: Code für diese Listener und die
Ereignisverarbeitung erstellen
 Schritt 3: Listener mit Applet registrieren
Java
am IAS
© 2012, IAS
151
Applet-Grundlagen
JDK 1.1 - Ereignismodell (2)
Schritt 1: Ereignisse und Listener-Schnittstellen
 die API-Dokumentation gibt Auskunft über Ereignisse und
ihre zugehörigen Listener-Schnittstellen
Listener-Interface
Ereignis
Definition (alle public void)
MouseListener
mouseDown
mouseUp
mouseEnter
mouseExit
mouseClicks
mousePressed (MouseEvent e)
mouseReleased (MouseEvent e)
mouseEntered (MouseEvent e)
mouseExited (MouseEvent e)
mouseClicked (MouseEvent e)
MouseMotionListener
mouseMove
mouseDrag
mouseMoved (MouseEvent e)
mouseDragged (MouseEvent e)
KeyListener
keyUp
keyDown
keyTyped
keyReleased (KeyEvent e)
keyPressed (KeyEvent e)
keyTyped (KeyEvent e)
Java
am IAS
© 2012, IAS
152
Applet-Grundlagen
JDK 1.1 - Ereignismodell (3)
Schritt 2: Listener-Schnittstellen implementieren
 der Ereignis-Listener ist eine Klasse, die die ListenerSchnittstelle implementiert
 Schnittstellen-Implementierung kann auf zwei Arten erfolgen:
(A) separate Listener-Klasse: elegante Lösung für größere
Programme
(B) Listener wird direkt in der Applet-Klasse implementiert:
schnelle Lösung für kleinere Applets
zu (A):
 separate Listener-Klasse muss Schnittstelle vollständig
implementieren
 für viele Listener stehen in java.awt.event sog. Adapterklassen
mit Default-Implementierungen zur Verfügung, z.B.:
MouseAdapter
MouseMotionAdapter
KeyAdapter
Java
am IAS
für
für
für
© 2012, IAS
MouseListener
MouseMotionListener
KeyListener
153
Applet-Grundlagen
JDK 1.1 - Ereignismodell (4)
Schritt 2 (Forts.): Listener-Schnittstellen implementieren
zu (A):
 von den Listener-Adapterklassen werden eigene ListenerKlassen abgeleitet, welche die relevanten
Ereignisbehandlungs-Methoden (z.B. mousePressed())
überschreiben
import java.awt.event.*;
class MeinMausListener extends MouseAdapter {
public void mousePressed( MouseEvent e ) {
...
}
}
Java
am IAS
© 2012, IAS
154
Applet-Grundlagen
JDK 1.1 - Ereignismodell (5)
Schritt 2 (Forts.): Listener-Schnittstellen implementieren
zu (B):
 das Applet ist sein eigener Event-Listener:
import java.awt.event.*;
public class MeinApplet extends java.applet.Applet
implements MouseListener, KeyListener {
// Ereignisbehandlung
public void mousePressed( MouseEvent e ) {
...
}
}
// Leer-Implementierungen der Schnittstelle
public void mouseReleased( MouseEvent e ) {}
...
 Wichtig: gesamte Schnittstelle muss implementiert
werden
Java
am IAS
© 2012, IAS
155
Applet-Grundlagen
JDK 1.1 - Ereignismodell (6)
Schritt 3: Listener registrieren
 Verbindung zwischen Listener und Applet mit
Registrierungsmethoden herstellen:
addMouseListener();
addMouseMotionListener();
addKeyListener();
 für separate Listener-Klasse
m1 = new MeinMausListener();
addMouseListener( m1 );
 Applet ist Listener
addMouseListener( this );
Java
am IAS
© 2012, IAS
156
Applet-Grundlagen
Mausereignisse (1)
Beispiel:
 folgendes Applet zeichnet gerade Linien auf den Bildschirm
durch Ziehen der Maus vom Anfangs- zum Endpunkt. Es
können maximal 10 Linien gezeichnet werden.
// Linien.java
import java.awt.*;
import java.awt.event.*;
public class Linien extends java.applet.Applet
implements MouseListener, MouseMotionListener {
final int MAXLINES = 10;
Point starts[] = new Point[MAXLINES]; // Startpunkte
Point ends[] = new Point[MAXLINES];
// Endpunkte
Point anchor;
// Start aktuelle Linie
Point currentpoint;
// Ende aktuelle Linie
int currline = 0;
// Anzahl Linien
Java
am IAS
© 2012, IAS
157
Applet-Grundlagen
Mausereignisse (2)
Beispiel (Forts.)
public void init() {
setBackground( Color.white );
// Event-Listener registrieren
addMouseListener( this );
addMouseMotionListener( this );
}
// Leerimplementierungen der Schnittstellen
public void mouseMoved( MouseEvent e) {}
public void mouseClicked( MouseEvent e) {}
public void mouseEntered( MouseEvent e) {}
public void mouseExited( MouseEvent e) {}
public void mousePressed( MouseEvent e ) {
if( currline < MAXLINES )
anchor = new Point( e.getX(), e.getY() );
else
System.out.println( "Too many lines ..." );
}
Java
am IAS
© 2012, IAS
158
Applet-Grundlagen
Mausereignisse (3)
Beispiel (Forts.)
public void mouseReleased( MouseEvent e ) {
if( currline < MAXLINES )
addLine( e.getX(), e.getY() );
}
public void mouseDragged( MouseEvent e ) {
if( currline < MAXLINES ) {
currentpoint = new Point( e.getX(), e.getY() );
repaint();
}
}
void addLine( int x, int y ) {
starts[currline] = anchor;
ends[currline] = new Point(x, y);
currline++;
currentpoint = null;
anchor = null;
repaint();
}
Java
am IAS
© 2012, IAS
159
Applet-Grundlagen
Mausereignisse (4)
Beispiel (Forts.)
public void paint( Graphics g ) {
for ( int i = 0; i < currline; i++ ) {
g.drawLine( starts[i].x, starts[i].y,
ends[i].x, ends[i].y );
}
}
Java
am IAS
}
g.setColor( Color.blue );
if( currentpoint != null )
g.drawLine( anchor.x, anchor.y,
currentpoint.x, currentpoint.y);
// Linien-Applet Ende
© 2012, IAS
160
Applet-Grundlagen
Mausereignisse (5)
Beispiel (Forts.)
Java
am IAS
© 2012, IAS
161
Applet-Grundlagen
Zusammenfassung
 Unterschied Applet - Applikation
 Applet-Aktivitäten: Initialisieren, Starten, Stoppen,
Zerstören, Anzeigen
 einfache Graphikoperationen: Linien, Rechtecke, ...
 Umgang mit Schriften
 Applet-Farben
 Bilder in Applets
 Ereignismodelle 1.1 und 1.02
 Ereignisbehandlung in Java
Java
am IAS
© 2012, IAS
162
Kursüberblick
Vierter Tag
Teil 1:
 Applet-Grundlagen
Teil 2:
 Elemente des AWT
Java
am IAS
© 2012, IAS
163
Elemente des AWT
AWT-Übersicht
 AWT bietetet eine Vielzahl von Komponenten für
graphische Benutzeroberflächen
 AWT-Elemente können in Containern verschachtelt werden
 wichtige AWT-Komponenten
• Container ermöglichen Verschachtelungen, sie können
konkrete Komponenten oder andere Container enthalten.
Häufigster Vertreter: Panel (Applet ist von Panel abgeleitet)
• Canvas ist ein Zeichenbereich zur Erstellung von Graphiken
• GUI-Komponenten, wie z.B. Labels, Schaltflächen,
Listenfelder, Textfelder, Kontrollfelder, u.s.w.
• Fensterkomponenten, wie z.B. Fenster, Rahmen,
Menüleisten, Dialogfelder
 alle Elemente sind als Klassenhierarchie im java.awt-Paket
organisiert
Java
am IAS
© 2012, IAS
164
Elemente des AWT
AWT- Label (1)
 Label: nicht-editierbare Zeichenkette, die zur Beschriftung
anderer Komponenten dient
 Vorteile von Labels (gegenüber drawString()):
• keine paint()-Anweisungen notwendig
• automatische Layout-Anpassungen
 Label-Konstruktoren:
• Label() erzeugt leeres, links ausgerichtetes Label
• Label( String ) erzeugt Label mit Zeichenkette
• Label( String, int ) ermöglicht Ausrichtung mit Hilfe von
Label-Klassenvariablen Label.RIGHT, Label.LEFT,
Label.CENTER
 die Schrift des Labels kann mit setFont() beliebig
geändert werden
Java
am IAS
© 2012, IAS
165
Elemente des AWT
AWT- Label (2)
Beispiel
import java.awt.*;
public class LabelTest extends java.applet.Applet {
public void init() {
setFont( new Font(“Helvetica”, Font.BOLD, 16));
setLayout( new GridLayout( 3, 1 ));
add( new Label(“linksgerichtet”, Label.LEFT));
add( new Label(“zentriert”, Label.CENTER));
add( new Label(“rechtsgerichtet”, Label.RIGHT));
}
}
 Label-Methoden:
• getText() gibt die Zeichenkette des Labels aus
• setText(String) ändert den Label-Text
• getAlignment() gibt die Ausrichtung des Label als Integer
zurück:
0 (links), 1 (zentriert) oder 2 (rechts)
• setAlignment(int) ändert die Label-Ausrichtung
Java
am IAS
© 2012, IAS
166
Elemente des AWT
AWT - Schaltflächen
 Schaltfläche (Button): kann mit der Maus “angeklickt”
werden und Aktionen auslösen
 Konstruktoren:
• Button() erzeugt Schaltfläche ohne Beschriftung
• Button( String ) erzeugt Schaltfläche mit String als
Beschriftung
 Methoden:
• getLabel() gibt die Beschriftung der Schaltfläche zurück
• setLabel( String ) beschriftet die Schaltfläche mit String
Beispiel
public class ButtonTest extends java.applet.Applet {
public void init() {
add( new Button(“OK”));
add( new Button(“Cancel”));
}
}
Java
am IAS
© 2012, IAS
167
Elemente des AWT
AWT - Kontrollfelder
 Kontrollfelder (Checkbox) stellen Optionen bereit, die gewählt
oder nicht gewählt werden können. Die Optionen schließen
sich nicht gegenseitig aus (Mehrfachauswahl möglich)
 Konstruktoren:
• Checkbox() erzeugt unbeschriftetes, nicht gewähltes Kontrollfeld
• Checkbox( String ) erzeugt Kontrollfeld mit StringBeschriftung
• Checkbox( String, boolean ) erzeugt beschriftetes
Kontrollfeld, welches ausgewählt (true) oder nicht ausgewählt
(false) ist
 Methoden:
•
•
•
•
Java
am IAS
getLabel() gibt Feldbeschriftung aus
setLabel( String ) ändert Feldbeschriftung
getState() gibt true oder false (je nach Selektion) aus
setState(boolean) ändert Auswahlstatus des Kontrollfeldes
© 2012, IAS
168
Elemente des AWT
AWT - Optionsfelder
 Optionsfelder (CheckboxGroup) sind ähnlich wie Kontrollfelder,
es kann allerdings nur eine Option gewählt werden. Die
einzelnen Optionen werden in einer CheckboxGroup gruppiert
Beispiel
public void init() {
setLayout( new FlowLayout( FlowLayout.LEFT ));
CheckboxGroup cbg = new CheckboxGroup();
add( new Checkbox( “Rot”, false, cbg));
add( new Checkbox( “Gruen”, false, cbg));
add( new Checkbox( “Blau”, true, cbg));
}
 Methoden:
•
•
•
•
Java
am IAS
getCheckboxGroup() gibt das aktuelle Optionsfeld zurück
setCheckboxGroup(CheckboxGroup) setzt aktuelles Optionsfeld
getSelectedCheckbox() gibt aktuell angewähltes Option zurück
setSelectedCheckbox(Checkbox) wählt die gewünschte Option an
© 2012, IAS
169
Elemente des AWT
AWT - Auswahlmenüs
 Auswahlmenüs (Choice) sind Pop-Up-Listen, aus denen ein
Listenelement ausgewählt werden kann
Beispiel
public void init() {
Choice c = new Choice();
c.add(“Java”);
c.add(“C++”);
c.add(“Ada95”);
add( c );
}
 Methoden:
getItem( int ) gibt Zeichenkette der gewählten Stelle (0,...) aus
getItemCount() gibt die Anzahl der Menüelemente aus
getSelectedIndex() gibt Index des gewählten Elements zurück
getSelectedItem() gibt Zeichenkette des gewählten Elements
zurück
• select( int ) wählt Element an der angegebenen Stelle
• select( String ) wählt Element mit der angegebenen Zeichenkette
•
•
•
•
Java
am IAS
© 2012, IAS
170
Elemente des AWT
AWT - Textfelder (1)
 Textfelder (TextField) stellen editierbaren Bereich für die
Eingabe einer Textzeile zur Verfügung
 Konstruktoren:
• TextField() erzeugt leeres Textfeld
• TextField( String ) erzeugt mit Zeichenkette initialisiertes
Textfeld, Breite wird durch aktuellen Layout-Manager
vorgegeben
• TextField( String, int ) erzeugt initialisiertes Textfeld mit
vorgegebener Breite (Zeichen)
TextField tf = new TextField(“ Erstes Textfeld”, 30);
add( tf );
 zur Beschriftung des Textfeldes muss ein zusätzliches Label
verwendet werden
Java
am IAS
© 2012, IAS
171
Elemente des AWT
AWT - Textfelder (2)
 Methoden:
getText() gibt Text als Zeichenkette aus
setText( String ) setzt Zeichenkette in das Feld
getColumns() gibt Breite des Textfeldes aus
select( int, int ) wählt Text zwischen beiden Positionen
aus
• selectAll() wählt den gesamten Text aus
• isEditable() gibt aus, ob Text editierbar ist (true/false)
• setEditable( boolean ) ermöglicht (true) oder verbietet
(false) editieren des Textes
•
•
•
•
Beispiel
public void init() {
setLayout( new GridLayout( 1, 2, 5, 15 ) );
add( new Label(“Name:”) );
add( new TextField(“Ihren Namen bitte”, 40) );
}
Java
am IAS
© 2012, IAS
172
Elemente des AWT
Layout-Manager
 jedes Applet (Panel) kann konkrete Komponenten oder
weitere Panels enthalten
 ein Layout-Manager bestimmt, wie die AWT-Elemente in
einem Panel dynamisch angeordnet werden
 jedes Panel kann einen eigenen Layout-Manager besitzten
 das AWT beinhaltet fünf verschiedene Layout-Manager:
FlowLayout, GridLayout, BorderLayout, CardLayout und
GridBagLayout
 ein Manager wird in einem Panel verwendet, indem a) eine
Instanz einer Layout-Manager-Klasse gebildet wird und b)
die setLayout()-Methode für das umgebende Panel
aufgerufen wird
 die Reihenfolgen, in der AWT-Elemente in das Layout
eingefügt werden (add()-Methode), ist entscheidend für
ihre Positionierung
Java
am IAS
© 2012, IAS
173
Elemente des AWT
FlowLayout
 das FlowLayout ordnet die Komponenten zeilenweise von links
nach rechts an. Passt eine Komponente nicht in die Zeile, wird
automatisch eine neue Zeile begonnen
 die zentrierte Zeilenausrichtung kann mit den Klassenvariablen
FlowLayout.RIGHT und FlowLayout.LEFT verändert werden
 der horizontale und vertikale Abstand kann durch zwei
Integer-Argumente angegeben werden
Beispiel
import java.awt.*;
public class FlowTest extends java.applet.Applet {
public void init() {
setLayout(new FlowLayout(FlowLayout.LEFT, 20, 20));
add(new Button("Eins"));
add(new Button("Zwei"));
add(new Button("Drei"));
add(new Button("Vier"));
}
}
Java
am IAS
© 2012, IAS
174
Elemente des AWT
GridLayout
 bei GridLayout wird das Panel in Zeilen und Spalten
unterteilt. Die Komponenten werden von links nach rechts
und von oben nach unten eingefügt
 auch hier können zusätzliche horizontale und vertikale
Abstände zwischen den Komponenten angegeben werden
Beispiel
import java.awt.*;
public class GridTest extends java.applet.Applet {
public void init() {
setLayout(new GridLayout(2, 2, 3, 10));
add(new Button("Eins"));
add(new Button("Zwei"));
add(new Button("Drei"));
add(new Button("Vier"));
}
}
Java
am IAS
© 2012, IAS
175
Elemente des AWT
BorderLayout
 beim BorderLayout werden Komponenten mit Hilfe von
geographischen Angaben (North, East, South, West,
Center) angeordnet
Beispiel
import java.awt.*;
public class BorderTest extends java.applet.Applet {
public void init() {
setLayout(new BorderLayout(5, 10));
add("North", new Button("Eins"));
add("East", new Button("Zwei"));
add("South", new Button("Drei"));
add("West", new Button("Vier"));
}
}
Java
am IAS
© 2012, IAS
176
Elemente des AWT
Card- und GridBagLayout
 die Karten in einem CardLayout sind unterschiedliche
Panels, die nacheinander eingefügt und angezeigt werden.
Es kann jeweils nur eine Karte angezeigt werden, aber man
kann zwischen den Karten wechseln
 das GridBagLayout ist der mächtigste, aber auch der
komplizierteste Layout-Manager - er ermöglicht die
Anordnung der Komponenten in einem rasterähnlichen
Layout
 im GridBagLayout kann zusätzlich die Weite der einzelnen
Zellen, sowie die Proportionen zwischen Zeilen und Spalten
kontrolliert werden
 die Fähigkeiten des GridBag-Manager können meistens
durch Verschachteln einfacherer Manager nachgebildet
werden
Java
am IAS
© 2012, IAS
177
Elemente des AWT
Listener für GUI-Komponenten (1)
Listener-Interface
Ereignis
Definition (alle public void)
ActionListener
Aktion
ItemListener
Liste
gewählt
itemStateChanged(ItemEvent e)
FocusListener
Fokuserhalt
Fokusverlust
focusGained(FocusEvent e)
focusLost(FocusEvent e)
TextListener
Text geändert textValueChanged(TextEvent e)
actionPerformed(ActionEvent e)
 die meisten dieser Listener-Schnittstellen (bis auf
FocusListener) besitzten keine Adapterklassen, d.h. die
Schnittstellen müssen von Hand implementiert werden
Java
am IAS
© 2012, IAS
178
Elemente des AWT
Listener für GUI-Komponenten (2)
 bei der Implementierung der Listener-Schnittstelle kann
mit Hilfe der getSource()-Methode eine Referenz auf die
Komponente ermittelt werden, die das Ereignis erhalten hat
public void actionPerformed( ActionEvent e ){
Button ursprung = e.getSource();
if( ursprung.getLabel().equals(“OK”)) {
// Behandlung von OK
} else if( ursprung.getLabel().equals(“Cancel”)) {
// Behandlung von Cancel
}
}
 Listener werden durch spezielle Methoden mit den
GUI-Elementen verbunden
addActionListener();
addItemListener();
addFocusListener();
Java
am IAS
© 2012, IAS
179
Elemente des AWT
Listener für GUI-Komponenten (3)
 für die Registrierung des Listeners in der init()-Methode
muss bei jeder empfangenden Komponente einzeln
registriert werden
Button OKButton = new Button(“OK”);
// OKButtonAction implementiert ActionListener
OKButtonAction ok = new OKButtonAction();
OKButton.addActionListener( ok );
 Details können der API-Dokumentation des jeweiligen
Oberflächenelements oder der Schnittstelle entnommen
werden
Java
am IAS
© 2012, IAS
180
Elemente des AWT
Listener für GUI-Komponenten (4)
Beispiel
import java.awt.*;
import java.awt.event.*;
public class MultiListener extends java.applet.Applet
implements ActionListener {
TextArea leftTextArea;
TextArea rightTextArea;
Button button1, button2;
public void init() {
GridLayout gridbag = new GridLayout(3, 2, 5, 5);
setLayout(gridbag);
Label l = new Label("Das Applet hoert:");
add(l);
Label r = new Label("Die externe Klasse hoert:");
add(r);
Java
am IAS
© 2012, IAS
181
Elemente des AWT
Listener für GUI-Komponenten (5)
Beispiel (Forts.)
leftTextArea = new TextArea(5, 20);
leftTextArea.setEditable(false);
add(leftTextArea);
rightTextArea = new TextArea(5, 20);
rightTextArea.setEditable(false);
add(rightTextArea);
button1 = new Button("Schaltflaeche 1");
add(button1);
button2 = new Button("Schaltflaeche 2");
add(button2);
button1.addActionListener(this);
button2.addActionListener(this);
button2.addActionListener(new
ExtListener(rightTextArea));
} // Ende init()-Methode
Java
am IAS
© 2012, IAS
182
Elemente des AWT
Listener für GUI-Komponenten (6)
Beispiel (Forts.)
public void actionPerformed(ActionEvent e) {
leftTextArea.append(e.getActionCommand() + "\n");
}
}
// Ende MultiListener-Klasse
class ExtListener implements ActionListener {
TextArea myTextArea;
public ExtListener(TextArea ta) {
myTextArea = ta;
}
public void actionPerformed(ActionEvent e) {
myTextArea.append(e.getActionCommand() + "\n");
}
}
Java
am IAS
© 2012, IAS
183
Elemente des AWT
Listener für GUI-Komponenten (7)
Java
am IAS
© 2012, IAS
184
Elemente des AWT
Zusammenfassung
 AWT bietet graphische Oberflächenelemente:
•
•
•
•
•
•
Labels
Schaltflächen
Kontrollfelder
Optionsfelder
Auswahlmenüs
Textfelder
 mit den fünf Layout-Managern können AWT-Komponenten
dynamisch angeordnet werden
 für die Komponenten-Ereignisse stehen spezielle
Schnittstellen
zur Verfügung
 eine Listener muss jeder einzelnen empfangenden
Komponente registriert werden
Java
am IAS
© 2012, IAS
185
Was wurde nicht behandelt?
 Threads (“Miniprozesse”)
z.B. Drucken im Hintergrund
 Java-Applikationen mit AWT
 Netzkommunikation, Client/Server-Applikationen
Java
am IAS
© 2012, IAS
186
Wie geht’s weiter ...
Selbststudium
 Literatur
 kleinere Programmierprojekte
Angebote am IAS
 Softwaretechnik-Praktikum am IAS
Ansprechpartner: Dipl.-Ing. Alexander Faul, Tel. 685-67305
Java
am IAS
© 2012, IAS
187