Grundlagen der Programmierung. Eine Einführung mit

Grundlagen der Programmierung.
Eine Einführung mit Java
Jürn Laun
VHS Murrhardt
März 2009
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Teil I
6. März 2009
1
Einführung
2
Grundlagen der objektorientierten Programmierung
3
Entwicklungsumgebung Eclipse
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
(De)Motivation
Programmieren kann man lernen, aber nicht lehren!
Warum trotzdem teilnehmen?
Einige Konzepte sind doch vermittelbar
Kurs beinhaltet viele Übungen und praktische Anwendungen
Fehlersuche ist frustrierend
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Nach dem Kurs. . .
. . . kennen Sie die wichtigsten Elemente einer
objektorientierten Programmiersprache
. . . können Sie kleine Programme selbst schreiben
. . . sind Sie in der Lage, sich alles Übrige selbst beizubringen
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Die Sprache
Java
Sun Microsystems 1991
Warum Java (und nicht Pascal,C++,C#,. . . )?
Warum nicht?
Objektorientierung
(relativ) saubere Konzepte
Einfache Erlernbarkeit
Verfügbarkeit auf allen Systemen und Portierbarkeit
Verbreitung
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Die Werkzeuge
Der Baukasten
Wir arbeiten mit dem Java SE Development Kit (JDK).
Verfügbar für nahezu alle Betriebssysteme „normaler” PC.
Kann von http://java.sun.com/ heruntergeladen werden.
Entwicklung für andere Plattformen: Java EE, Java ME
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Die Werkzeuge
Der Compiler: javac
Prüft und übersetzt den Quellcode in ein (lauffähiges) Programm.
Der Interpreter: java
Führt das Programm aus.
Die Entwicklungsumgebung: Eclipse
Vereint alle Funktionalität unter einer Oberfläche: Editieren,
Kompilieren, Debuggen, . . .
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Dieser Kurs deckt nicht ab:
konzeptuell unwichtige Details der Java-Syntax
völlig abgedrehte Konzepte objektorientierter
Programmiersprachen wie Templates und Mehrfachvererbung
Feinheiten der GUI-Programmierung
Java EE und ME
Webapplikationen
Weitere Java-eigene und -nahe Technologien wie Applets
(ansatzweise, wenn die Zeit reicht), Beans, Servlets, Javadoc,
...
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Und Sie?
Vorkenntnisse?
Erwartungen?
Wünsche?
...
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
(De)Motivation
Inhalt und Ziele
Die Sprache
Die Werkzeuge
Was fehlt
Inhalt
1
Einführung
2
Grundlagen der objektorientierten Programmierung
3
Entwicklungsumgebung Eclipse
4
Strukturierte Programmierung in Java
5
Objektorientierte Programmierung in Java (Teil I)
6
Objektorientierte Programmierung in Java (Teil II)
7
Projekt (Teil I)
8
Weitere Techniken und Features von Java
9
Projekt (Teil II)
10
Ausblick
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Hallo, Welt!
Hallo.java
public class Hallo
{
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
{
System . o u t . p r i n t l n ( " H a l l o , ␣ Welt ! " ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Klassen und Objekte
Objekte
Objekte sind Repräsentationen von realen oder abstrakten
Dingen im Speicher.
Objekte besitzen Daten („Eigenschaften”) und Aktionen
(„Methoden”).
Klassen
Klassen beschreiben den Typ eines Objekts.
Jedes Objekt ist Instanz einer Klasse.
Eine Klasse kann keine, eine oder viele Instanzen haben.
Wir fassen Objekte nie direkt an, sondern benutzen
Referenzen.
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Beispiel: In Bildern...
drucken(
)
void
)
void
em
ai
lS
Jürn Laun
n(
tri
n(S
de
en
Murrhardt”
!strasse=“Obere Schulgasse 7”
!plz=71540
!ort=”Murrhardt”
!email=”[email protected]”
boolean plz
Pru
ef
e
ng text)
!name=“VHS
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Klassen und Objekte
Objekte
Objekte sind Repräsentationen von realen oder abstrakten
Dingen im Speicher.
Objekte besitzen Daten („Eigenschaften”) und Aktionen
(„Methoden”).
Klassen
Klassen beschreiben den Typ eines Objekts.
Jedes Objekt ist Instanz einer Klasse.
Eine Klasse kann keine, eine oder viele Instanzen haben.
Wir fassen Objekte nie direkt an, sondern benutzen
Referenzen.
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Beispiel: In Bildern...
Adresse
drucken(
)
void
meineAdresse
Eigenschaften
!String name
!String strasse
!Integer plz
!String ort
!String email
tri
n(S
de
en
n(
ng text)
tri
n(S
void
em
ai
lS
de
en
)
)
void
em
ai
lS
Jürn Laun
boolean plz
Pru
ef
e
Murrhardt”
!strasse=“Obere Schulgasse 7”
!plz=71540
!ort=”Murrhardt”
!email=”[email protected]”
n(
!name=“VHS
boolean plz
Pru
ef
e
drucken()
void
Methoden
!void drucken()
!boolean plzPruefen()
!void emailSenden(String text)
Mittel”
!strasse=“Mittelgasse 5”
!plz=12321
!ort=”Mittelbach”
!email=”[email protected]”
ng text)
!name=“Max
maxensAdresse
maxensVHS
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Beispiel: In Java...
A d r e s s e m e i n e A d r e s s e , m a x e n s A d r e s s e , maxensVHS ;
meineAdresse
meineAdresse
meineAdresse
meineAdresse
meineAdresse
meineAdresse
= new A d r e s s e ( ) ;
. name = "VHS␣ M u r r h a r d t " ;
. s t r a s s e = " Obere ␣ S c h u l g a s s e ␣ 7 " ;
. p l z = 71540;
. or t = " Murrhardt" ;
. e m a i l = " i n f o @ v h s −m u r r h a r d t . de " ;
meineAdresse . drucken ( ) ;
m e i n e A d r e s s e . e m a i l S e n d e n ( " H a l l o , ␣VHS ! " ) ;
m a x e n s A d r e s s e = new A d r e s s e ( ) ;
// . . .
maxensVHS = m e i n e A d r e s s e ;
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Der Umgang mit Objekten
Objekte anlegen (Objekt ist Instanz einer Klasse!)
Klasse referenz ;
r e f e r e n z = new K l a s s e (< e v t l . Parameter >);
Oder auf einmal:
K l a s s e r e f e r e n z = new K l a s s e (< e v t l . Parameter >);
null
Referenzen, die (noch) auf keine Instanz zeigen (z.B. direkt nach
der ersten Zeile im obigen Beispiel), haben den speziellen Wert null .
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Der Umgang mit Objekten
Objekte verwenden („dot notation”)
// Z u g r i f f a u f E i g e n s c h a f t e n
referenz . eigenschaft = . . . ;
System . o u t . p r i n t l n ( r e f e r e n z . e i g e n s c h a f t ) ;
// Z u g r i f f a u f Methoden
r e f e r e n z . methode(< Parameter >);
. . . = r e f e r e n z . methode2 (< Parameter >);
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Der Umgang mit Objekten
Objekte löschen?
Nicht nötig! Java hat Garbage Collection - Objekt wird gelöscht,
sobald es keine Referenzen mehr darauf gibt.
Klasse ref1 , ref2 ;
r e f 1 = new K l a s s e ( ) ;
ref2 = ref1 ;
// r e f 1 a u f n u l l s e t z e n
ref1 = null ;
// noch e x i s t i e r t d a s O b j e k t !
ref2 = null ;
// e r s t j e t z t w i r d e s ( i r g e n d w a n n ) g e l ö s c h t .
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Beispiel mit echten Java-Klassen
Beispiel
// R e f e r e n z f ü r O b j e k t e vom Typ I n t e g e r
I n t e g e r meineZahl ;
// E r z e u g e n e i n e s I n t e g e r −O b j e k t e s ( i n i t i a l i s i e r t m i t 5 )
m e i n e Z a h l = new I n t e g e r ( 5 ) ;
// A u f r u f e n d e r Methode t o S t r i n g
S t r i n g meinString = meineZahl . t o S t r i n g ( ) ;
// E r z e u g e n e i n e s z w e i t e n I n t e g e r −O b j e k t e s
I n t e g e r a n d e r e Z a h l = new I n t e g e r ( 1 7 ) ;
// Methode compareTo a u f r u f e n und E r g e b n i s a u s g e b e n
System . o u t . p r i n t l n ( m e i n e Z a h l . compareTo ( a n d e r e Z a h l ) ) ;
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Einige Java-eigene Klassen und Methoden
Genaue Beschreibungen aller Klassen und deren Eigenschaften und
Methoden in der API-Referenz [2]
Klasse
Methode
Beschreibung
String
boolean startsWith ( String )
String replace ( char s , char r )
String toUpperCase()
String concat( String )
Zeichenketten
vergleicht Strings ohne Beachtung
von Groß-/Kleinschreibung
prüft, ob der String mit einem anderen beginnt
ersetzt alle Zeichen s durch r
wandelt den String in Großbuchstaben um
hängt einen String an einen anderen
void print ( String )
void println ( String )
Ausgabestrom - etwas, in das man „hineinschreiben”
kann, z.B. Konsole, Dateien, . . .
System.out ist Instanz von PrintStream
schreibt einen String in den Ausgabestrom
schreibt einen String und geht in die nächste Zeile
String readLine ()
Repräsentiert die Konsole („Eingabeaufforderung”)
System.console() gibt eine Instanz zurück
liest einen String von der Konsole
boolean equalsIgnoreCase ( String )
PrintStream
Console
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Die hat doch jeder...
Einige Methoden existieren in jeder Klasse:
// v e r g l e i c h t d a s O b j e k t m i t einem a n d e r e n d e r s e l b e n K l a s s e
b o o l e a n e q u a l s (K)
// e r s t e l l t
K clone ()
e i n e Kopie des O b je k t s
// B e i s p i e l :
K r e f 1 = new K ( ) , r e f 2 ;
ref2 = ref1 ;
// i s t e t w a s a n d e r e s a l s
K r e f 1 = new K ( ) , r e f 2 ;
ref2 = ref1 . clone ( ) ;
// g e n e r i e r t e i n e Z e i c h e n k e t t e , d i e d a s O b j e k t b e s c h r e i b t
String toString ()
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Hallo, Welt!
Klassen, Objekte und Referenzen
Üben und Vertiefen
1
2
3
Erweitern Sie Hallo.java zu einem Programm Hallo2.java,
das den Benutzer zunächst nach seinem Namen fragt und ihn
dann mit „Hallo, <Name>!” begrüßt.
Kompilieren Sie das Programm, indem Sie in der Konsole in
das Verzeichnis von Hallo2.java wechseln und javac
Hallo2.java eingeben. Beseitigen Sie eventuell auftretende
Fehler.
Führen Sie das Programm mit java Hallo2 aus.
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Entwicklungsumgebung Eclipse
Das Arbeiten mit Editor und Konsole ist mühsam. Deshalb
verwenden wir die Entwicklungsumgebung (IDE - Integrated
Development Environment) Eclipse:
(Halb-)Automatisches Erzeugen von Klassen(-rümpfen)
Hilfe beim Editieren (z.B. Einblenden von Methoden und
Eigenschaften gerade verwendeter Klassen und Objekte)
Automatisches Kompilieren im Hintergrund und Anzeigen der
Fehler im Quellcode
Debugging
Jürn Laun
Grundlagen der Programmierung
Einführung
Grundlagen der objektorientierten Programmierung
Entwicklungsumgebung Eclipse
Üben und Vertiefen
1
2
3
Erstellen Sie mit Eclipse ein Projekt Hallo, legen Sie eine
Klasse desselben Namens und mit einer main-Methode an und
implementieren Sie ein Programm, das „Hallo, Eclipse!”
ausgibt.
Öffnen Sie das vorbereitete Projekt Eclipse und führen Sie
das Programm aus. Was passiert? Gehen Sie mit Hilfe des
Debuggers schrittweise durch das Programm und versuchen
Sie seine Arbeitsweise zu verstehen.
Schreiben Sie ein Programm Datum, das das aktuelle Datum
und die Uhrzeit ausgibt. Tipp: Die Klasse Date und die
API-Referenz könnten hilfreich sein.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Teil II
7. März 2009
4
Strukturierte Programmierung in Java
5
Objektorientierte Programmierung in Java (Teil I)
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Grundlegende Syntax
Jeder Befehl wird mit Semikolon (;) abgeschlossen
Geschweifte Klammern {. . . } gruppieren Befehle zu Blöcken
Kommentare werden vom Compiler ignoriert (sind aber für den
Menschen umso wichtiger!)
Einzeilig: von // bis zum Zeilenende
Mehrzeilig: zwischen /* und */
JavaDoc: zwischen /** und */
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Grundlegende Syntax
Selbstgewählte Bezeichner (also Namen von Klassen,
Objekten, . . . )
nur Buchstaben und Ziffern (keine Sonderzeichen außer _)
beginnen immer mit einem Buchstaben
keine reservierten Schlüsselwörter ( class , new,. . . )
auf Groß-/Kleinschreibung achten
Üblich: Referenzen und Methoden klein, Klassen beginnen mit
Großbuchstaben, mehrere Wörter mit gemischter Schreibweise
(z.B. MeineKlasse, meinObjekt), Konstanten vollständig in
Großbuchstaben (z.B. PI)
Java-Sprachreferenz [1]
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Primitive Datentypen
Spezielle Klassen, die besonders häufig gebraucht werden.
Vor allem für numerische Daten:
byte, short , int , long,
float , double,
boolean,
char
Aus Effizienzgründen keine echten Klassen:
Keine Referenzen (= (Zuweisung) wirkt wie clone())
Keine Methoden
Operatoren (z.B. +, -, *, /, %, !, ++, ==, < usw.)
Sprechweise: „Typ” statt „Klasse”, „Variable” statt „Objekt”
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Beispiel: Kasse
Ideale objektorientierte Sprache
F l o a t p r e i s 1 , p r e i s 2 = new F l o a t ( 1 9 . 9 5 ) ;
p r e i s 1 = new F l o a t ( 7 . 9 9 ) ;
Float netto = p re is1 . addiere ( p re is2 ) ;
F l o a t b r u t t o = n e t t o . m u l t i p l i z i e r e ( new F l o a t ( 1 . 1 9 ) ) ;
System . o u t . p r i n t l n ( b r u t t o ) ;
Java
f l o a t p reis1 , p r e i s 2 = 19.95 f ;
p r e i s 1 = 7.99 f ;
f l o a t netto = p re is1 + pre i s2 ;
f l o a t brutto = netto ∗ 1.19 f ;
System . o u t . p r i n t l n ( b r u t t o ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Umgang mit Variablen
1
Deklaration: Dem Compiler mitteilen, dass Speicherplatz
reserviert werden soll. Optional Initialisierung.
int i ;
i n t j = 15;
2
Zuweisung: Einen Wert in einer Variable ablegen.
i = 27;
i = j;
3
Operationen: mit Werten (von Variablen) rechnen.
i = ( j + 1) ∗ 3 ;
j = 17 / 2 ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Primitive Datentypen im Einzelnen: Ganze Zahlen
Typ
Werte
Operatoren
Varianten
int
−231 , . . . , 231 − 1
+, −, ∗
/, % (Division und Rest)
++, −− (In−/Dekrement)
==, !=, <, >, <=, >= (Vergleich)
− (unär)
byte (−128, . . . , 127)
short (−215 , . . . , 215 − 1)
long (−263 , . . . , 263 − 1)
Jürn Laun
int i = j + 3;
int zeit = 92 % 24;
i ++;
boolean b = (a >= 7);
int neg = −i;
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Primitive Datentypen im Einzelnen: Gleitkommazahlen
Typ
Werte
Operatoren
Varianten
float
±1.4e − 45, . . . , ±3.4e38
+, −, ∗, /
==, !=, <, >, <=, >= (Vergleich)
− (unär)
double (±4.9e −324, . . . , ±1.8e308)
Jürn Laun
float x = y + 2.8f;
boolean b = (a >= 7.0f);
float neg = −x;
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Primitive Datentypen im Einzelnen: Zeichen
Typ
Werte
Operatoren
Besonderheiten
char
. . . ,’A’,’B’,. . . ,’a’,’b’,. . .
==, !=, <, >, <=, >= (Vergleich)
’n’ Zeilenumbruch
’\t ’ Tabulator
’\"’ Anführungszeichen
’ \’ ’ Apostroph
’\\’ Backslash
’\u0065’ Unicode-Zeichen
Jürn Laun
boolean b = (c == ’g’);
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Primitive Datentypen im Einzelnen: Wahrheitswerte
Typ
Werte
Operatoren
boolean
true , false
! (Negation)
&& (logisches Und)
|| ( logisches Oder)
Besonderheiten
Rückgabewert der
Vergleichsoperatoren
Jürn Laun
boolean erfolg = ! fehler ;
boolean gueltig = (i > 0) && (i < 10);
boolean antwort = (c==’j’) || (c==’n’);
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Typumwandlungen
Wir können Variablen eines Typs in solche eines anderen Typs
umwandeln:
Typecasts
int i = 5 , j = 7;
f l o a t f = 2.4 f , g = 2.14 f , h = 3.8 f ;
f = ( float ) i ;
// J e t z t h a t f den Wert 5 . 0 f
f = ( f l o a t ) ( i + j ) ; // Nun i s t f g l e i c h 1 2 . 0 f
i = ( int )g;
j = ( int )(h − g );
// i bekommt den Wert 2
// J e t z t h a t j den Wert 1
Bei Typumwandlungen können Daten verloren gehen!
Nicht alle Typen lassen sich sinnvoll ineinander umwandeln.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Konstanten
Variablen, deren Wert nicht geändert werden kann.
Beispiel
final
f l o a t PI = 3 . 1 4 1 5 9 f ;
f l o a t radius = 3.5 f ;
f l o a t umfang = 2 . 0 f ∗ PI ∗ r a d i u s ;
PI = 3 . 1 f ; // C o m p i l e r m e l d e t F e h l e r !
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Eingabe
Einlesen von Zeichenketten
BufferedReader br =
new B u f f e r e d R e a d e r ( new I n p u t S t r e a m R e a d e r ( System . i n ) ) ;
S t rin g s = br . readLine ( ) ;
Einlesen primitiver Datentypen
BufferedReader br =
new B u f f e r e d R e a d e r ( new I n p u t S t r e a m R e a d e r ( System . i n ) ) ;
i n t i = I n t e g er . p a rs e I n t ( br . readLine ( ) ) ;
f l o a t f = Float . p arseFloat ( br . readLine ( ) ) ;
char c = ( char ) br . read ( ) ;
In der ersten Zeile: import java . io .∗;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Ausgabe
Ausgeben von primitiven Datentypen und Zeichenketten
System . o u t . p r i n t ( 2 5 ) ;
System . o u t . p r i n t l n ( 3 . 7 5 f ) ;
System . o u t . p r i n t ( " H a l l o , ␣ Welt ! " ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Üben und Vertiefen
1
2
Schreiben Sie ein Programm AddSub, das den Benutzer zwei
Gleitkommazahlen eingeben lässt und deren Summe und
Differenz berechnet.
Schreiben Sie ein Programm DM2EUR, das einen vom Benutzer
eingegebenen DM-Betrag in Euro umrechnet.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Felder
Felder
Felder sind Sammlungen mehrerer Variablen (oder Objekte) des
gleichen Typs (oder der gleichen Klasse).
Sie werden – wie Objekte – immer mit Referenzen verwendet und
mit new angelegt. Auch dann, wenn sie primitive Typen enthalten!
Beispiel
int [] feld ;
f e l d = new i n t [ 1 0 0 ] ;
f e l d [ 0 ] = 17;
int i = feld [29];
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Felder
length
Jedes Feld-Objekt hat eine Eigenschaft length vom Typ int , welche
die Anzahl der Feldelemente angibt.
Die Elemente eines Feldes sind von 0 bis feld . length−1 indiziert.
Felder von Objekten
Enthält das Feld Objekte, dann erzeugt
Klasse [ ] fe ld ;
f e l d = new K l a s s e [ 1 0 0 ] ;
nur die Referenzen, nicht die hundert Objekte selbst! Das muss in
einem zweiten Schritt getan werden:
f e l d [ 0 ] = new K l a s s e ( ) ; f e l d [ 1 ] = new K l a s s e ( ) ; // . . .
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrdimensionale Felder
Es gibt auch Felder mit Elementen vom Typ int [] (analog für
andere Typen oder Klassen als int ), also Felder von Feldern:
int [ ] [ ] feldfeld ;
f e l d f e l d = new i n t [ 3 ] [ ] ;
ist nun ein Feld von (Referenzen auf) int -Felder, welches im
Moment aber nur null-Referenzen enthält.
feldfeld
feldfeld
feldfeld
feldfeld
feldfeld
[ 0 ] = new i n t [ 4 ] ;
[ 1 ] = new i n t [ 7 ] ;
[ 2 ] = new i n t [ 2 ] ;
[ 1 ] [ 5 ] = 13;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrdimensionale Felder
feldfeld
13
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrdimensionale Felder
Es geht auch kürzer: Sollen alle Einzelfelder gleich groß sein, so
können wir anstelle von
int [ ] [ ]
feldfeld
feldfeld
feldfeld
feldfeld
feldfeld ;
= new i n t
[ 0 ] = new
[ 1 ] = new
[ 2 ] = new
[3][];
int [4] ;
int [4] ;
int [4] ;
auch schreiben:
int [ ] [ ] feldfeld ;
f e l d f e l d = new i n t [ 3 ] [ 4 ] ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Wie wird ein Programm ausgeführt?
Zunächst immer eine Anweisung nach der anderen.
Das reicht nicht! Wir wollen
bestimmte Anweisungen wiederholt ausführen (Schleifen)
manche Anweisungen nur unter bestimmten Bedingungen
ausführen (Verzweigung)
Im Debugger von eclipse kann der Kontrollfluss (in welcher
Reihenfolge werden welche Anweisungen ausgeführt)
nachvollzogen werden.
Kontrollstrukturen steuern den Kontrollfluss
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Verzweigung ( if )
Syntax
i f ( h Wert vom Typ b o o l e a n i )
hAnweisung o d e r B l o c k i
[ else
hAnweisung o d e r B l o c k i ]
Wenn die if-Bedingung den Wert true hat, wird die erste Anweisung
ausgeführt, sonst (falls vorhanden) die zweite.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Verzweigung ( if )
Beispiel
i f ( d != 0 . 0 f )
{
float q = a / d;
System . o u t . p r i n t l n ( q ) ;
}
else
System . o u t . p r i n t l n ( " U n g ü l t i g e r ␣ T e i l e r " ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrfachverzweigung (switch)
Syntax
s w i t c h ( h Wert vom Typ i n t , s h o r t , b y t e o d e r c h a r i )
{
c a s e h Wert vom e n t s p r e c h e n d e n Typ i :
[ h Anweisungen i ]
[ break ; ]
..
.
[ default :
[ h Anweisungen i ]
[ break ; ] ]
}
Die Anweisungen des Falles, der dem gegebenen Wert entspricht,
werden ausgeführt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrfachverzweigung (switch)
Beispiel
switch ( stunde )
{
case 7:
System . o u t . p r i n t l n ( " Guten ␣ Morgen ! " ) ;
break ;
case 17:
case 18:
System . o u t . p r i n t l n ( " Guten ␣ Abend ! " ) ;
break ;
default :
System . o u t . p r i n t l n ( " Guten ␣Tag ! " ) ;
break ;
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Mehrfachverzweigung (switch)
switch kann immer durch eine Kette von if ... else if ... else ...
ersetzt werden:
Beispiel
i f ( s t u n d e == 7 )
System . o u t . p r i n t l n ( " Guten ␣ Morgen ! " ) ;
e l s e i f ( s t u n d e == 17 | | s t u n d e == 1 8 )
System . o u t . p r i n t l n ( " Guten ␣ Abend ! " ) ;
else
System . o u t . p r i n t l n ( " Guten ␣Tag ! " ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Schleifen (while)
Syntax
w h i l e ( h Wert vom Typ b o o l e a n i )
hAnweisung o d e r B l o c k i
Solange die Bedingung den Wert true hat, wird die Anweisung
wiederholt ausgeführt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Schleifen (do ... while)
Syntax
do
hAnweisung o d e r B l o c k i
w h i l e ( h Wert vom Typ b o o l e a n i ) ;
Bei dieser Variante wird die Anweisung mindestens einmal
durchgeführt, da die Bedingung erst nach dem Durchlauf der
Schleife geprüft wird.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Schleifen (do ... while)
Beispiel
BufferedReader br =
new B u f f e r e d R e a d e r ( new I n p u t S t r e a m R e a d e r ( System . i n ) ) ;
S t r i n g pswd ;
do
{
System . o u t . p r i n t ( " P a s s w o r t ␣ e i n g e b e n : " ) ;
pswd = b r . r e a d L i n e ( ) ;
}
w h i l e ( pswd . e q u a l s ( " geheim " ) ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Zählschleife ( for )
Syntax
f o r (h I n i t i a l i s i e r u n g i ; h B e d i n g u n g i ; h I n k r e m e n t i )
hAnweisung o d e r B l o c k i
Zunächst wird die Initialisierungsanweisung durchgeführt, dann der
Schleifenrumpf, solang die Bedingung wahr ist. Nach jedem
Durchlauf wird die Inkrementierungsanweisung durchgeführt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Zählschleife ( for )
Beispiel: Berechnen der ersten 10 Quadratzahlen
f o r ( i n t i = 0 ; i < 1 0 ; i ++)
System . o u t . p r i n t l n ( i ∗ i ) ;
Beispiel: Ausgeben eines Feldes
f l o a t [ ] f e l d = new f l o a t [ 1 4 ] ;
// . . .
f o r ( i n t i = 0 ; i < f e l d . l e n g t h ; i ++)
System . o u t . p r i n t l n ( f e l d [ i ] ) ;
// o d e r k ü r z e r :
for ( float f : feld )
System . o u t . p r i n t l n ( f ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Üben und Vertiefen I
1
2
Schreiben Sie ein Programm Schaltjahr, das den Benutzer
nach einer Jahreszahl fragt und dann ermittelt, ob dieses Jahr
ein Schaltjahr ist. (Tipp: Der Operator % berechnet den Rest
beim Teilen einer Zahl durch eine andere. Zweiter Tipp: Jedes
vierte Jahr ist ein Schaltjahr, außer die hundertsten, es sei
denn, sie sind durch 400 teilbar.)
Öffnen Sie das vorbereitete Projekt Debug. Dieses Programm
soll den Benutzer nach einer Zahl fragen und die Summe
0 + 1 + . . . bis zu der eingegebenen Zahl berechnen. Leider hat
sich ein Fehler eingeschlichen. Finden Sie ihn mit Hilfe des
Eclipse-Debuggers!
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Grundlegende Syntax
Typen, Variablen & Konstanten
Ein- und Ausgabe
Felder
Kontrollstrukturen
Üben und Vertiefen II
3
4
Schreiben Sie ein Programm Mittel, das Folgendes tut:
Zunächst wird der Benutzer gefragt, wieviele Zahlen er
eingeben möchte. Dann werden diese in ein Feld eingelesen.
Anschließend wird deren Mittelwert berechnet und ausgegeben.
Innerhalb von Schleifen sind die Anweisungen break und
continue erlaubt. Finden Sie experimentell oder durch
Nachschlagen in der Sprachreferenz [1] heraus, was diese
Anweisung bewirkt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Klassen definieren
Adresse.java
[ public ] c l as s Adresse
{
// E i g e n s c h a f t e n und Methoden
}
A d r e s s e m e i n e A d r e s s e = new A d r e s s e ( ) ;
Jede .java-Datei sollte eine Klasse gleichen Namens enthalten,
welche public deklariert ist. Alle anderen Klassen sind Hilfsklassen
und nach außen nur eingeschränkt sichtbar. Am besten jede Klasse
in eine eigene Datei stecken!
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Eigenschaften definieren
Adresse.java
public c l a s s Adresse
{
p u b l i c S t r i n g name , s t r a s s e ;
}
// v e r w e n d e n d e r K l a s s e und i h r e r E i g e n s c h a f t :
A d r e s s e m e i n e A d r e s s e = new A d r e s s e ( ) ;
m e i n A d r e s s e . name = new S t r i n g ( "VHS␣ M u r r h a r d t " ) ;
Eigenschaften einer Klasse können Variablen oder Objekte sein.
Was der Zusatz public bedeutet werden wir später sehen.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Methoden definieren
Adresse.java
public cl ass Adresse
{
p u b l i c S t r i n g name , s t r a s s e ;
public void drucke ()
{
System . o ut . p r i n t l n ( name . append ( " ␣ " ) . append ( s t r a s s e ) ) ;
}
}
// A u f r u f d e r Methode :
A d r e s s e m e i n e A d r e s s e = new A d r e s s e ( ) ;
m e i n e A d r e s s e . name = new S t r i n g ( "VHS␣ M u r r h a r d t " ) ;
m e i n e A d r e s s e . s t r a s s e = new S t r i n g ( " Obere ␣ S c h u l g a s s e " ) ;
meineAdresse . drucke ( ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Zugriff auf Eigenschaften und Methoden
Innerhalb einer Methode einer Klasse erhält man eine Referenz auf
das eigene Objekt mit this . Der Zugriff auf Eigenschaften und
Methoden des eigenen Objekts kann aber auch ohne Referenz .
erfolgen:
MeineKlasse.java
p u b l i c c l a s s MeineKlasse
{
p u b lic in t meineEigenschaft ;
p u b l i c v o i d mei neM ethode1 ( ) { /∗ . . . ∗/ }
p u b l i c v o i d mei neM ethode2 ( )
{
t h i s . meineEigenschaft = 7;
t h i s . mei neM ethode1 ( ) ;
meineEigenschaft = 5;
mei neM ethode1 ( ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Methoden: Parameter
Parameter
p u b l i c void drucke ( S t r i n g t e x t )
{
System . o u t . p r i n t l n ( m e i n S t r i n g . append ( t e x t ) ) ;
}
// A u f r u f d e r Methode :
m e i n O b j e k t . d r u c k e ( " i r g e n d e i n ␣ Text " ) ;
Der Wert " irgendein ␣Text" wird beim Aufruf in die nur innerhalb der
Methode gültige Variable text kopiert.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Methoden: Rückgabewert
Parameter
p u b l i c i n t summe ( i n t wert1 , i n t w e r t 2 )
{
i n t s = wert1 + wert2 ;
return s ;
}
// A u f r u f d e r Methode :
i n t meineSumme = m e i n O b j e k t . summe ( 2 , 3 ) ;
Wird kein Rückgabewert benötigt, so verwendet man den speziellen
Typ void.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Methoden: Überladen
Überladene Methode
p u b l i c void drucke ( S t r i n g t e x t )
{
System . o u t . p r i n t l n ( m e i n S t r i n g . append ( t e x t ) ) ;
}
p u b l i c v o i d d r u c k e ( P r i n t S t r e a m ps , S t r i n g t e x t )
{
p s . p r i n t l n ( m e i n S t r i n g . append ( t e x t ) ) ;
}
// A u f r u f d e r Methoden :
m e i n O b j e k t . d r u c k e ( " i r g e n d e i n ␣ Text " ) ;
m e i n O b j e k t . d r u c k e ( System . out , " noch ␣ e i n ␣ Text " ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Konstruktoren
Wozu sind die Klammern beim Erstellen eines Objektes gut?
M e i n e K l a s s e m e i n O b j e k t = new M e i n e K l a s s e ( ) ;
Antwort: Beim Anlegen des Objektes wird eine spezielle Methode –
der Konstruktor – aufgerufen. Er kann genutzt werden, um das
Objekt zu initialisieren – z.B. den Eigenschaften Standardwerte
zuzuweisen.
Der Konstruktor heißt immer so wie die Klasse.
Er kann überladen werden und Parameter bekommen.
Der parameterlose Konstruktor heißt „Standardkonstruktor”.
Konstruktoren haben keinen Rückgabewert, auch nicht void .
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Konstruktoren
Konstruktoren
c l ass MeineKlasse
{
public int meineEigenschaft ;
public MeineKlasse ()
{
meineEigenschaft = 11;
}
p u b l i c M e i n e K l a s s e ( i n t param )
{
m e i n e E i g e n s c h a f t = param ;
}
}
// A n l e g e n von O b j e k t e n :
M e i n e K l a s s e m e i n O b j e k t 1 = new M e i n e K l a s s e ( ) ;
M e i n e K l a s s e m e i n O b j e k t 2 = new M e i n e K l a s s e ( 1 3 ) ;
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Destruktoren
Destruktoren werden beim Löschen eines Objekts aufgerufen. Sie
können Aufräumarbeiten vornehmen. Dank Garbage Collection
braucht man Destruktoren nur selten – das meiste räumt sich von
selbst auf.
Destruktor
c l a s s MeineKlasse
{
public int meineEigenschaft ;
protected void f i n a l i z e ()
{
meineEigenschaft = 0;
}
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Üben und Vertiefen
1
Schreiben Sie eine Klasse Buch, die in einer
Bibliotheksverwaltung verwendet werden könnte. Ihre Klasse
sollte geeignete Eigenschaften (Titel, Autor, ist das Buch
ausgeliehen und an wen?, . . . ) und Methoden ausleihen und
zurueckgeben besitzen. Welche Konstruktoren sollte die Klasse
Buch sinnvollerweise bekommen? Schreiben Sie ein
Testprogramm, das einige Buch-Instanzen anlegt, deren
Eigenschaften ändert und Methoden aufruft.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Parameter
Der Wert einer als Parameter übergebenen Variablen ändert nach
außen nicht, wenn er innerhalb der Methode verändert wird („call
by value”):
Primitive Datentypen als Parameter
p u b l i c v o i d meineMethode ( i n t param )
{
param = 3 ;
System . o u t . p r i n t l n ( param ) ; // Ausgabe : 3
}
// A u f r u f d e r Methode :
int i = 5;
m e i n O b j e k t . meineMethode ( i ) ;
System . o u t . p r i n t l n ( i ) ; // Ausgabe : 5
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Parameter
Objekte als Parameter
p u b l i c c l a s s AndereKlasse { p u b l i c i n t a n de r e Eig e n s c ha ft ;}
p u b l i c i n t MeineKlasse
{
p u b l i c v o i d mei neM ethode1 ( A n d e r e K l a s s e param )
{
param = new A n d e r e K l a s s e ( ) ;
param . a n d e r e E i g e n s c h a f t = 3 ;
}
p u b l i c v o i d mei neM ethode2 ( A n d e r e K l a s s e param )
{
param . a n d e r e E i g e n s c h a f t = 3 ;
}
}
// A u f r u f d e r Methoden :
M e i n e K l a s s e m e i n O b j e k t = new M e i n e K l a s s e ( ) ;
A n d e r e K l a s s e a n d e r e s O b j e k t = new A n d e r e K l a s s e ( ) ;
anderesObjekt . andereEigenschaft = 2;
m e i n e K l a s s e . mei neM ethode1 ( a n d e r e s O b j e k t ) ;
Sy stem . o u t . p r i n t l n ( a n d e r e s O b j e k t . a n d e r e E i g e n s c h a f t ) ; // Ausgabe : 2
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Parameter
Objekte als Parameter
p u b l i c c l a s s AndereKlasse { p u b l i c i n t a n de r e Eig e n s c ha ft ;}
p u b l i c i n t MeineKlasse
{
p u b l i c v o i d mei neM ethode1 ( A n d e r e K l a s s e param )
{
param = new A n d e r e K l a s s e ( ) ;
param . a n d e r e E i g e n s c h a f t = 3 ;
}
p u b l i c v o i d mei neM ethode2 ( A n d e r e K l a s s e param )
{
param . a n d e r e E i g e n s c h a f t = 3 ;
}
}
// A u f r u f d e r Methoden :
M e i n e K l a s s e m e i n O b j e k t = new M e i n e K l a s s e ( ) ;
A n d e r e K l a s s e a n d e r e s O b j e k t = new A n d e r e K l a s s e ( ) ;
anderesObjekt . andereEigenschaft = 2;
m e i n e K l a s s e . mei neM ethode2 ( a n d e r e s O b j e k t ) ;
Sy stem . o u t . p r i n t l n ( a n d e r e s O b j e k t . a n d e r e E i g e n s c h a f t ) ; // Ausgabe : 3
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Gültigkeit und Sichtbarkeit
Der Umgang mit Variablen wird ein bisschen komplizierter, wenn
Methoden im Spiel sind.
Während des Ablaufs eines Programmes heißt eine Variable
gültig, solange sie im Speicher vorhanden ist.
Eine Variable nennt man zu einem Zeitpunkt eines
Programmablaufs sichtbar, wenn sie mit ihrem Namen
angesprochen werden kann.
Dassebe gilt für Referenzen anstelle von Variablen.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Gültigkeit und Sichtbarkeit
Beispiel 1
1
2
3
4
5
6
int
{
i = 0;
Variable
i
j
int j = 5;
i = 7;
}
j = 0;
Jürn Laun
gültig
1-6
3-4
Grundlagen der Programmierung
sichtbar
1-6
3-4
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Gültigkeit und Sichtbarkeit
Beispiel 2
1
2
3
4
5
6
7
8
9
10
11
12
13
p u b l i c v o i d methode1 ( )
{
int i = 13;
methode2 ( ) ;
i = 7;
}
p u b l i c v o i d methode2 ( )
{
int j = 11;
System . o ut . p r i n t l n ( j ) ;
}
Variable
i
j
gültig
3,4,9,10,5
9,10
// methode1 w i r d a u f g e r u f e n
Jürn Laun
Grundlagen der Programmierung
sichtbar
3,4,5
9,10
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Gültigkeit und Sichtbarkeit
Beispiel 3
1
2
3
4
5
6
7
8
9
public int i ;
public
{
i =
int
int
i =
}
v o i d methode ( )
13;
i = 17;
j = 2;
7;
Jürn Laun
Variable
i
i
j
gültig
4-7
5-7
6-7
Grundlagen der Programmierung
sichtbar
4
5-7
6-7
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Üben und Vertiefen
1
Ermitteln Sie den
Ablauf des
Programmes auf der
rechten Seite, wenn
methode1 aufgerufen
wird. Wann sind die
einzelnen Variablen
gültig, wann sichtbar?
Welche Werte haben
sie?
Jürn Laun
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public int i ;
p u b l i c v o i d methode1 ( )
{
i = 13;
int i = 17;
int j = 2;
methode2 ( ) ;
i = 7;
}
p u b l i c v o i d methode2 ( )
{
int j = 0;
i = 5;
int i ;
int k = 2;
i = 11;
}
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Rekursion
Methoden können andere Methoden aufrufen, aber auch sich selbst.
Eine solche Rekursion kann ein effizienter Weg zur Lösung mancher
Probleme sein. Aber Achtung vor versteckten Endlos„schleifen”!
Beispiel
public int fakultaet ( int n)
{
i f ( n = 0)
return 1;
else
return n ∗ fakul taet (n − 1);
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Kapselung
Die zuvor betrachtete Klasse Adresse ist nicht sicher gegenüber
unsinnigen Aktionen. Zum Beispiel können wir eine Instanz mit
negativer Hausnummer oder nichtexistenter Postleitzahl
anlegen und verwenden.
Idee: Klassen sollten gekapselt sein, d.h. ihre Eigenschaften
sollten von außen nicht direkt zugänglich sein, sondern nur
über Methoden der Klasse. Diese können Tests durchführen
und verhindern, dass eine Instanz in einen unsinnigen Zustand
kommt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Kapselung
!name=“VHS Murrhardt”
!strasse=“Obere Schulgasse 7”
!plz=71540
!ort=”Murrhardt”
!email=”[email protected]”
g
n)
String getNam
e(
)
e
void s tName(
St
rin
...
drucken()
void
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Kapselung
Beispielsweise können wir für die Eigenschaft plz zwei
Methoden void setPlz ( int ) und int getPlz () anlegen.
Wir brauchen also einen Weg, den Zugriff auf Eigenschaften
für jeden außer den eigenen Methoden der Klasse zu
unterbinden.
Dasselbe für Methoden (z.B. Hilfsmethoden, die von außen
nicht aufrufbar sein sollen)
Lösung: public und private
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
public
und
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
private
Beispiel
c l ass MeineKlasse
{
public int eigenschaft1 ;
private int eigenschaft2 ;
p u b l i c v o i d methode1 ( )
{
eigenschaft1 = 5; eigenschaft2 = 7;
methode2 ( ) ;
}
p r i v a t e v o i d methode2 ( )
{
eigenschaft1 = 2; eigenschaft2 = 3;
}
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
public
und
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
private
Beispiel (Fortsetzung)
M e i n e K l a s s e m e i n O b j e k t = new M e i n e K l a s s e ( ) ;
meinObjekt . e i g e n s c h a f t 1 = 17;
m e i n O b j e k t . methode1 ( ) ;
i n t i = m e i n O b j e k t . e i g e n s c h a f t 2 ; // C o m p i l e r f e h l e r !
m e i n O b j e k t . methode2 ( ) ; // C o m p i l e r f e h l e r !
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Richtlinien
Eigenschaften von Klassen sind (fast) immer gekapselt.
Die Methoden stellen sicher, dass sich Instanzen immer in
einem konsistenten Zustand befinden.
Klassen vertrauen niemandem außer ihren eigenen Methoden.
Z.B. werden Parameter, die von außen kommen, immer als
kontaminiert betrachtet und erst nach eingehender Prüfung in
das Objekt übernommen.
Jede Klasse ist eine in sich funktionsfähige Einheit und kann
wiederverwendet werden (und wir wissen nicht in welchem
Kontext).
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Üben und Vertiefen
1
Überarbeiten Sie die Klasse Adresse, so dass sie diesen
Anforderungen genügt.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Statische Eigenschaften und Methoden
Gelegentlich gehören Eigenschaften eher zur Klasse als zu ihren
Instanzen. Gründe können sein:
Der Wert muss für alle Instanzen der Klasse derselbe sein.
Es darf aus gewissen Gründen nur eine einzige Instanz der
Klasse geben (z.B. die Klasse System im Java-API).
Konstanten müssen nicht in jeder einzelnen Instanz gespeichert
werden (können es aber).
Datenaustausch zwischen verschiedenen Instanzen einer Klasse.
Solche Eigenschaften heißen statisch.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Statische Eigenschaften und Methoden
Adresse
Eigenschaften
!String name, strasse
!int hnr
!static boolean strasseVorHnr= true
Methoden
!static void formatSetzen(boolean)
!void drucken()
meineAdresse
drucken(
)
void
!name=“VHS
Murrhardt”
!strasse=“Obere Schulgasse 7”
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Statische Eigenschaften und Methoden
Beispiel
c l ass Adresse
{
p r i v a t e S t r i n g name , s t r a s s e ;
pr iva t e i n t hnr ;
p r i v a t e s t a t i c bo o le a n s t r a s s e V o r H n r ;
p u b l i c s t a t i c v o i d f o r m a t S e t z e n ( bo o le a n s t r V o r H )
{ s tr a s s eV or H nr = strVorH ; }
public void drucken ()
{
i f ( strasseVorHnr )
System . o ut . p r i n t l n ( name + s t r a s s e + h n r ) ;
e l s e System . o ut . p r i n t l n ( name + h n r + s t r a s s e ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Regeln
Beim Verwenden statischer Eigenschaften und Methoden ist zu
beachten:
Nichtstatische Methoden können auf statische Eigenschaften
und Methoden zugreifen.
Statische Methoden können auf statische Eigenschaften und
Methoden zugreifen.
Statische Methoden können nicht auf nichtstatische
Eigenschaften und Methoden zugreifen. Warum?
this
ist in statischen Methoden nicht definiert.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Beispiele im Java-API
Wir haben statische Eigenschaften und Methoden schon häufiger
verwendet:
und out sind statische Eigenschaften der Klasse System.
(System hat überhaupt nur statische Eigenschaften und
Methoden.)
in
Die Methode parseInt der Klasse Integer ist statisch.
Die main-Methode in unseren Programmen ist statisch.
Jürn Laun
Grundlagen der Programmierung
Strukturierte Programmierung in Java
Objektorientierte Programmierung in Java (Teil I)
Klassen, Eigenschaften und Methoden definieren
Konstruktoren und Destruktoren
Mehr über Methoden
Kapselung
Statische Eigenschaften und Methoden
Üben und Vertiefen
1
2
Ergänzen Sie die Klasse Buch um eine statische Methode
int anzahlAusgeliehen () , die sie Anzahl der ausgeliehenen Bücher
zurückgibt.
Man kann Konstruktoren auch private definieren. Wenn alle
Konstruktoren einer Klasse private sind, können dann noch
Instanzen der Klasse erstellt werden? Welchen Sinn könnte
diese Vorgehensweise haben?
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Teil III
13. März 2009
6
Objektorientierte Programmierung in Java (Teil II)
7
Projekt (Teil I)
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Einführendes Beispiel
Angenommen, wir wollen eine große Adresskartei mit Hilfe einer
Klasse Adresse verwalten. Allerdings tauchen in unserem
Datenbestand sowohl normale Adressen, als auch Postfachadressen
auf. Wir benötigen also zwei verschiedene Adressklassen.
Hausadresse
Postfachadresse
Eigenschaften
!String name
!String strasse
!int hnr, plz
!String ort
Eigenschaften
!String name
!int postfach
!int plz
!String ort
Methoden
!void drucken()
!boolean plzPruefen()
Methoden
!void drucken()
!boolean plzPruefen()
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Einführendes Beispiel
Diese Vorgehensweise hat einige Nachteile:
Methoden, die bei beiden Klassen gleich sind (wie z.B.
plzPruefen müssen doppelt implementiert (und schlimmer:
gewartet) werden.
Wir können unsere Adresssammlung nicht mehr in einem
großen Feld vom Typ Adresse [] halten, da die Elemente
Instanzen zweier verschiedener Klassen sind. Die Trennung in
zwei Felder ist logisch nicht sinnvoll.
Jede Methode, die auf Adressen zugreift, muss eine
Fallunterscheidung durchführen, auch wenn die durchgeführte
Operation gar nicht von der genauen Art der Adresse abhängt.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Einführendes Beispiel
Lösung: Wir fassen die Gemeinsamkeiten beider Klassen in einer
Oberklasse Adresse zusammen:
Adresse
Eigenschaften
!String name
!int plz
!String ort
Methoden
!void drucken()
!boolean plzPruefen()
Hausadresse
Postfachadresse
Eigenschaften
!String strasse
!int hnr
Eigenschaften
!int postfach
Methoden
!void drucken()
!boolean plzPruefen()
Jürn Laun
Methoden
!void drucken()
!boolean plzPruefen()
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Ableiten von Klassen
Dies nennt man „Ableiten einer Klasse von einer Basisklasse”
(englisch „derivation”). In Java:
c l a s s BasisKlasse
{
public int eigenschaft1 ;
p u b l i c v o i d methode1 ( ) { /∗ . . . ∗/ }
}
c l a s s Abgelei teteKl asse extends BasisKlasse
{
public int eigenschaft2 ;
p u b l i c v o i d methode2 ( ) { /∗ . . . ∗/ }
}
Die abgeleitete Klasse erbt alle Eigenschaften und Methoden der
Basisklasse. Sie hat also zwei Eigenschaften und zwei Methoden:
A b g e l e i t e t e K l a s s e m e i n O b j e k t = new A b g e l e i t e t e K l a s s e ( ) ;
meinObjekt . e i g e n s c h a f t 2 = 5 ;
meinObjekt . e i g e n s c h a f t 1 = 7 ;
m e i n O b j e k t . methode1 ( ) ;
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Überschreiben
Eine abgeleitete Klasse kann Methoden, die sie von der Basisklasse
erbt, neu definieren. Dies nennt man „Überschreiben” (eine falsche
Übersetzung von „Overriding”).
Überschreiben ist notwendig, um das Verhalten einer Klasse zu
ändern.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Beispiel
Adressverwaltung
c l a s s Adresse
{
p u b l i c S t r i n g name , o r t ;
pub lic in t plz ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
p u b l i c b o o l e a n p l z P r u e f e n ( ) { /∗ . . . ∗/ }
}
c l a s s Hausadresse extends Adresse
{
public String strasse ;
p u b l i c i n t hnr ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
c l a s s P os tf a ch a d re s s e extends Adresse
{
pub lic in t postfach ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Vererbung
Zwischen einer abgeleiteten Klasse und ihrer Basisklasse besteht die
„ist ein(e)”-Beziehung:
Eine Hausadresse ist eine Adresse.
Eine Postfachadresse ist eine Adresse.
Deshalb dürfen wir schreiben:
A d r e s s e m e i n e A d r e s s e = new H a u s A d r e s s e ( ) ;
A d r e s s e v h s A d r e s s e = new P o s t f a c h A d r e s s e ( ) ;
Referenzen vom Typ der Basisklasse dürfen auch Instanzen
abgeleiteter Klassen enthalten!
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Vererbung
In unserem Adressbeispiel zeigt sich, dass dies sehr praktisch ist:
Adressverwaltung
A d r e s s e [ ] m e i n e K a r t e i = new A d r e s s e [ 5 0 0 ] ;
// . . .
m e i n e K a r t e i [ 3 7 5 ] = new H a u s A d r e s s e ( ) ;
m e i n e K a r t e i [ 3 7 5 ] . s t r a s s e = " Obere ␣ S c h u l g a s s e " ;
// . . .
f o r ( i n t i = 0 ; i < m e i n e K a r t e i . l e n g t h ; i ++)
meineKartei [ i ] . drucken ( ) ;
Wir müssen uns in der Schleife überhaupt nicht darum kümmern,
von welcher Klasse das Objekt meineKartei[ i ] genau ist. Java ruft
automatisch die richtige drucken-Methode auf!
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Üben und Vertiefen
1
2
3
Entwerfen Sie neue Klassen für unsere Bibliotheksverwaltung:
Es sollen nun verschiende Medien verwaltet werden: Bücher,
Zeitschriften und DVDs. Alle Medien besitzen einen Titel und
den Status „ausgeliehen” oder „nicht ausgeliehen”. Bücher
haben außerdem einen Autor und eine ISBN-Nummer,
Zeitschriften eine Nummer und DVDs einen Regisseur.
Wie ändern Sie die Ihre eben entworfenen Klassen am besten,
wenn Printmedien (also Bücher und Zeitschriften) eine
Eigenschaft „Verlag” bekommen sollen, DVDs aber nicht?
Erklären Sie den Unterschied zwischen Überladen und
Überschreiben!
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Klassenhierarchien
Die Struktur, die entsteht, wenn man Klassen mit ihren
Ableitungsbeziehungen darstellt, heißt Klassenhierarchie.
Zum Beispiel bilden die Klassen des Java-API eine solche
Hierarchie. −→ Klassenhierarchie des Java-API
Die Mutter aller Klassen ist Object. Jede Klasse, die nicht explizit
mit extends von einer anderen Klasse abgeleitet wurde, erhält vom
Java-Compiler automatisch die Basisklasse Object.
Object enthält z.B. die Methoden toString () und clone () , deshalb hat
– via Vererbung – jede Klasse diese Methoden.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Zugriff auf die Elternklasse: super
Oft wollen wir in einer abgeleiteten Klasse das Verhalten einer
Methode der Basisklasse nicht komplett verändern, sondern nur
ergänzen. Java bietet deshalb die Möglichkeit, auf Methoden der
Basisklasse zuzugreifen, auch wenn diese überschrieben wurde:
c l a s s AuslandsAdresse extends Hausadresse
{
public String land ;
p u b l i c void drucken ()
{
super . drucken ( ) ;
System . o u t . p r i n t l n ( l a n d ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Zugriffsbeschränkungen in abgeleiteten Klassen
Erinnerung: Auf private -Eigenschaften und -Methoden können nur
Methoden der Klasse selbst zugreifen.
Also auch keine Methoden abgeleiteter Klassen! Wir möchten aber
nicht alles public machen, nur damit Ableiten noch Sinn macht.
Die neue Zugriffsbeschränkung protected ist ein Kompromiss:
Methoden der Klasse selbst haben Zugriff.
Methoden abgeleiteter Klassen haben Zugriff.
Alle anderen haben keinen Zugriff (wie bei private ).
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Zugriffsbeschränkungen in abgeleiteten Klassen
Beispiel
c l a s s BasisKlasse
{
private int priEig ;
p rot e ct ed i n t proEig ;
p u b l i c i n t pubEig ;
p u b l i c v o i d methode1 ( )
{
p r i E i g = 2 ; p r o E i g = 3 ; p u b E i g = 5 ; //
}
Ist
alles
}
c l a s s Abgelei teteKl asse extends BasisKlasse
{
p u b l i c v o i d methode2 ( )
{
p r o E i g = 7 ; p u b E i g = 1 1 ; // Ok .
priE ig = 13;
// F e h l e r !
methode1 ( ) ;
// I n d i r e k t e r Z u g r i f f
// ü b e r Methoden d e r
// B a s i s k l a s s e b l e i b t
}
}
Jürn Laun
erlaubt .
erlaubt .
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Üben und Vertiefen
1
Ergänzen Sie Ihre Bibliotheksklassen aus den vorangegangenen
Aufgaben durch geeignete Zugriffsbeschränkungen. Beachten
Sie das Prinzip der Kapselung, d.h. verwenden Sie so wenig
public wie möglich.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Abstrakte Klassen und Polymorphie
Wir betrachten noch einmal die Klassen unseres Beispiels
Adressverwaltung.
Wie sollen wir die Methode Adresse.drucken() implementieren?
Am besten wäre, wir könnten die Implementierung dieser Methode
weglassen, denn wir wollen ohnehin keine Instanzen von Adresse
erstellen.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Beispiel
Adressverwaltung
c l a s s Adresse
{
p u b l i c S t r i n g name , o r t ;
pub lic in t plz ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
p u b l i c b o o l e a n p l z P r u e f e n ( ) { /∗ . . . ∗/ }
}
c l a s s Hausadresse extends Adresse
{
public String strasse ;
p u b l i c i n t hnr ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
c l a s s P os tf a ch a d re s s e extends Adresse
{
pub lic in t postfach ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Abstrakte Klassen und Polymorphie
Wir betrachten noch einmal die Klassen unseres Beispiels
Adressverwaltung.
Wie sollen wir die Methode Adresse.drucken() implementieren?
Am besten wäre, wir könnten die Implementierung dieser Methode
weglassen, denn wir wollen ohnehin keine Instanzen von Adresse
erstellen.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Beispiel
Adressverwaltung mit abstrakter Basisklasse
a b s t r a c t c l a s s Adresse
{
p u b l i c S t r i n g name , o r t ;
pub lic in t plz ;
p u b l i c a b s t r a c t vo id drucken ( ) ;
p u b l i c b o o l e a n p l z P r u e f e n ( ) { /∗ . . . ∗/ }
}
c l a s s Hausadresse extends Adresse
{
public String strasse ;
p u b l i c i n t hnr ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
c l a s s P os tf a ch a d re s s e extends Adresse
{
pub lic in t postfach ;
p u b l i c v o i d d r u c k e n ( ) { /∗ . . . ∗/ }
}
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Abstrakte Klassen und Polymorphie
Abstrakte Klassen können nicht instanziiert werden.
Sie legen eine Schnittstelle für ihre abgeleiteten Klassen fest
(z.B. muss jede nicht-abstrakte von Adresse abgeleitete Klasse
die Methode drucken implementieren.
Abgeleitete Klassen können einheitlich behandelt werden, denn
Basisklassenreferenzen können Instanzen abgeleiteter Klassen
enthalten.
Java sucht für solche Referenzen zur Laufzeit die richtigen
Methoden, auch wenn zum Zeitpunkt des Kompilierens noch
gar nicht feststand, von welchem Typ das entsprechende
Objekt sein würde. Dies nennt man Polymorphie (Ein
Hausadresse-Objekt kann verschiedene Gestalten haben:
Hausadresse, Adresse oder Object).
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Üben und Vertiefen
1
Welche Klassen aus unserem Bibliotheksbeispiel sollten wir
sinnvollerweise abstrakt definieren?
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Interfaces (Schnittstellen)
Wir treiben das Konzept der abstrakten Klassen auf die Spitze:
Eine abstrakte Klasse, die nur abstrakte Methoden besitzt, legt
lediglich die Schnittstelle ihrer abgeleiteten Klassen fest, stellt aber
keinerlei Funktionalität zur Verfügung.
Solche Klassen heißen in Java Interfaces.
Die Namen der meisten Interfaces endet auf -able (also -bar), z.B.
Runnable
(hat eine Methode run),
Serializable
Cloneable
(kann sich auf der Festplatte speichern),
(implementiert die clone -Methode) oder
(implementiert die Methode compareTo und kann
deshalb z.B. sortiert werden).
Comparable
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Interfaces (Schnittstellen)
Beispiele
i n t e r f a c e Druckbar
{
p u b l i c vo i d drucken ( PrintStream ) ;
}
c l a s s M eineK lasse implements Druckbar
{
// . . .
p u b l i c v o i d d r u c k e n ( P r i n S t r e a m p s ) { p s . p r i n t l n ( t i t e l ) ; /∗ . . . ∗/ }
}
c l a s s BildschirmDrucker
{
p u b l i c s t a t i c v o i d druckeE twas ( Druckbar etwas )
{
e t w a s . d r u c k e n ( Sy stem . o u t ) ;
}
}
// . . .
M e i n e K l a s s e m e i n O b j e k t = new M e i n e K l a s s e ( ) ;
B i l d s c h i r m D r u c k e r . druckeE twas ( meinObjekt ) ;
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Vererbung und Polymorphie
Interfaces
Interfaces vs. abstrakte Klassen
Abstrakte Klasse
kann implementierte
Methoden enthalten
Interface
alle Methoden sind
abstrakt
Klassen können nur
eine Basisklasse haben
Klassen können viele
Interfaces
implementieren
kann Konstruktoren
haben
hat keine
Konstruktoren
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Projekt: Vier Gewinnt
Im Laufe des Kurses wollen wir ein kleines Projekt durchführen:
Eine Java-Implementierung des Spiels „Vier Gewinnt”.
Wir beginnen heute mit den Klassen für das Spielfeld und die
Spieler. Später werden wir (wenn die Zeit reicht) ein grafisches
Interface dafür schreiben.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Vier Gewinnt: Das Spielbrett
• • • • • • •
Das Spielfeld besteht aus 7 Spalten und 6 Zeilen.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Vier Gewinnt: Die Spielregeln
• • • • • • •
•
• •
Die beiden Spieler werfen abwechselnd eine Kugel mit ihrer Farbe in
eine der Spalten.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Vier Gewinnt: Die Spielregeln
• •
•
•
•
• •
• • • • •
•
• • •
• • •
•
Wer zuerst 4 Kugeln in einer Reihe (waagerecht, senkrecht oder
diagonal) hat, gewinnt.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Klasse Spielbrett
Eigenschaften:
Konstanten HOEHE=6, BREITE=7
Ein zweidimensionales Array brett , welches die Kugeln auf dem
Spielbrett speichert. (0: keine Kugel, 1 bzw. 2: Kugel von
Spieler 1 bzw. 2)
Methoden:
void steinSetzen ( int spieler , int spalte )
boolean hatGewonnen(int spieler ) , boolean remis()
boolean spielBeendet ()
void anzeigen(PrintStream ps)
Jürn Laun
gibt das Spielbrett nach ps aus.
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Die Ausgabe des Spielbretts auf der Konsole könnte z.B. so
aussehen:
| | | | | | | |
| | | | | | | |
| | | |2| | | |
| | |2|1| | | |
| | |1|2|1| | |
| |2|1|1|2| | |
--------------Tipp: for -Schleifen können hier hilfreich sein!
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Abstrakte Klasse Spieler
Eigenschaften:
meineNummer
speichert die Nummer des Spielers, d.h. 1 oder 2.
Methoden:
nummerZuweisen(int nummer) setzt die Spielernummer auf
nummer
Abstrakte Methode int ziehen( Spielstand ) , welche die Nummer
der Zeile zurückgibt, in die der Spieler seine Kugel werfen will.
Im Prinzip könnten wir der Methode ziehen das Spielbrett als
Parameter übergeben. Der Spieler benötigt diese Information, um
zu entscheiden wie er spielt.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Allerdings könnte er dann auch schummeln (z.B. das Spielbrett
verändern oder mehrfach ziehen). Deshalb definieren wir ein
Interface Spielstand , welches nur lesenden Zugriff auf das Spielbrett
zulässt. Die Klasse Spielbrett soll dieses Interface implementieren.
Interface Spielstand
Methoden:
int breite (), int hoehe() sollen die Breite und Höhe des
Spielbretts zurückgeben.
int wessenStein( int spalte , int zeile ) soll die Nummer des
Spielers zurückgeben, dem der Stein in der gegebenen Spalte
und Zeile gehört (oder 0, wenn dort kein Stein liegt).
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Klasse MenschlicherSpieler (abgeleitet von Spieler )
Methoden:
Implementiert die abstrakte Methode ziehen von Spieler . Darin
soll er den Benutzer via Konsole nach der gewünschten Spalte
fragen.
Klasse ComputerSpieler (abgeleitet von Spieler )
Diese Klasse wird vom Dozent bereitgestellt.
Methoden:
Implementiert die abstrakte Methode ziehen von Spieler .
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassen und Interfaces
Klasse VierGewinnt
Methoden:
Legt ein Array vom Typ Spieler [] an, füllt dies mit zwei
Intanzen von MenschlicherSpieler oder ComputerSpieler und geht
anschließend in eine Schleifen, in der das Spielfeld angezeigt
und die Spieler abwechselnd nach ihrem Zug gefragt werden
und dieser ausgeführt wird.
main
Tipp: Es wird sich später als praktisch erweisen, wenn Sie eine
Variable amZug verwenden, die die Nummer des Spielers speichert,
der am Zug ist.
Jürn Laun
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Klassendiagramm
<<interface>>
Spieler
Spielstand
Eigenschaften
!int meineNummer
Methoden
!int breite()
!int hoehe()
!int wessenStein(int, int)
Methoden
!void nummerZuweisen(int)
!int ziehen(Spielstand)
VierGewinnt
Methoden
!static void main(String[])
Spielbrett
ComputerSpieler
MenschlicherSpieler
Eigenschaften
???
Methoden
!int ziehen(Spielstand)
???
Methoden
!int ziehen(Spielstand)
Jürn Laun
Eigenschaften
!final int BREITE, HOEHE
!int[][] brett
Methoden
!void steinSetzen(int, int)
!boolean hatGewonnen(int)
!boolean remis()
!boolean spielBeendet()
!void anzeigen(PrintStream)
Grundlagen der Programmierung
Objektorientierte Programmierung in Java (Teil II)
Projekt (Teil I)
Das Spiel
Klassen und Interfaces
Ein Test
Wenn Sie sauber programmiert haben, können Sie dank
Polymorphie durch Abändern von maximal zwei Code-Zeilen
zwischen den vier Spielvarianten „Mensch vs. Mensch”, „Mensch vs.
Computer”, „Computer vs. Mensch” und „Computer vs. Computer”
wechseln.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Teil IV
14. März 2009
8
Weitere Techniken und Features von Java
9
Projekt (Teil II)
10
Ausblick
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Fehlerbehandlung mit Rückgabewerten
Was tun, wenn in einer Methode ein Fehler auftritt? (z.B. eine zu
ladende Datei lässt sich nicht öffnen, eine Netzwerkverbindung
bricht zusammen, . . . )
Wir können die Methode mit return verlassen und anhand des
Rückgabewertes mitteilen, dass ein Fehler aufgetreten ist.
Dies ist aber mühsam bei verschaltelten Methodenaufrufen:
Angenommen methode1 ruft methode2 und diese methode3 auf und in
letzterer tritt ein Fehler auf. methode2 muss dann extra eine Abfrage
durchführen und den Fehler an methode1 „weiterleiten”.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Fehlerbehandlung mit Ausnahmen
Java stellt das Konzept der Exceptions zur Verfügung. Diese
können geworfen und gefangen werden:
FIXME: Bild
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Beispiel
Exceptions in Java
p u b l i c v o i d methode1 ( ) throws E x c e p t i o n
{
// . . .
throw new E x c e p t i o n ( " F e h l e r b e s c h r e i b u n g " ) ;
// . . .
}
p u b l i c v o i d methode2 ( )
{
try
{
methode1 ( ) ;
}
catch ( Ex cepti on e )
{
System . o ut . p r i n t l n ( " F e h l e r : " + e . t o S t r i n g ( ) ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Regeln für Verwendung von Exceptions
Wenn in einer Methode eine Exception geworfen werden kann,
so muss dieser Bereich von einem try -Block umschlossen oder
die Methode mit throws gekennzeichnet werden.
Innerhalb eines catch(Exception e)-Blocks kann eine gefangene
Exception mit throw e; weitergeworfen werden (z.B. wenn man
feststellt, dass man diesen speziellen Fehler doch nicht an
dieser Stelle behandeln kann).
Wird eine Exception gar nicht gefangen, so stoppt der
Interpreter die Ausführung des Programmes mit einer
Fehlermeldung.
Selbstdefinierte Exceptions können durch Ableiten von der
Klasse Exception erzeugt werden. Sie müssen das Interface
Throwable implementieren.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Multithreading
Den Ablauf eines Programmes stellen wir uns wie einen Zeiger vor,
der von Befehl zu Befehl wandert bzw. springt. Manchmal ist es
sinnvoll, zwei dieser „Zeiger”, d.h. zwei parallele Kontrollflüsse zu
haben:
Beispiel
Ein Programm führt eine länger andauernde Operation durch (z.B.
Kopieren einer großen Datei, Warten auf Netzwerkantwort) und soll
währenddessen auf Benutzereingaben (z.B. „Abbrechen”) reagieren
können.
Solche Abläufe oder „Zeiger” heißen Threads und die Verwendung
von mehreren „Multithreading”.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Multithreading: Technisches
Jedes Programm hat von Haus aus genau einen Thread. Dieser
besteht aus dem Abarbeiten der main-Methode.
Ein Thread kann mit Hilfe der statischen Methode
sleep ( int millisec ) der Klasse Thread für die angegebene Zeit
pausieren, z.B. wenn er auf ein Ereignis wartet.
Ein Programm startet einen zweiten Thread, indem es eine
Instanz der Klasse Thread erstellt und deren Konstruktor ein
Runnable-Objekt übergibt. Der Thread ruft dann die Methode
void run() dieses Objekts auf.
Ein Thread-Objekt wird mit der Methode void start () der Klasse
Thread gestartet.
Ein Thread kann mit der Methode interrupt () unterbrochen
werden, er selbst kann dies mit interrupted () abfragen.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Beispiel
Multithreading
p u b l i c c l a s s L a n g e O p e r a t i o n implements R unna bl e
{
public void run ()
{
w h i l e ( ! Thread . i n t e r r u p t e d ( ) )
/∗ f ü h r e e i n e O p e r a t i o n d u r c h ∗/ ;
}
}
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Beispiel
Multithreading
p u b l i c c l a s s Hauptprogramm
{
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
{
L a n g e O p e r a t i o n m e i n e O p e r a t i o n = new L a n g e O p e r a t i o n ( ) ;
Thread m e i nT hr e a d = new Thread ( m e i n e O p e r a t i o n ) ;
m e i nT hr e a d . s t a r t ( ) ;
System . o ut . p r i n t l n ( "Zum␣ A bbr e c he n ␣ Z e i c h e n ␣ e i n g e b e n ! " ) ;
System . i n . r e a d ( ) ;
m e i nT hr e a d . i n t e r r u p t ( ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Synchronisation
Wenn zwei Threads auf dieselbe Variable zugreifen kann dies zu
unerwarteten Ergebnissen führen:
1. Thread
2. Thread
v o i d methode1 ( )
{
i f ( i > 0 ) i ++;
}
v o i d methode2 ( )
{
i −−;
}
Wir können verhindern, dass eine Methode während ihrer
Ausführung einen anderen Thread zum Zuge kommen lässt, indem
wir sie mit synchronized kennzeichnen.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Applets
Java ist durch Applets erst richtig bekannt geworden.
Applets sind eine spezielle Art von Java-Programmen, die in
Webseiten eingebunden werden können. Java ist hierfür besonders
gut geeignet, da es plattformunabhängig funktioniert.
−→ Beispiel
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Applets: Technisches
Applets werden von der Klasse Applet abgeleitet.
Es gibt keine main-Methode, sondern Applets arbeiten (wie die
meisten Programme mit grafischer Oberfläche) ereignis- oder
nachrichtenorientiert.
Solche Programme bestehen aus Sammlungen von Reaktionen
(in Form von Methoden) auf Ereignisse wie Mausklicks,
Tastatureingaben etc.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Beispiel
HalloApplet.java
impo r t j a v a . a p p l e t . A p p l e t ;
impo r t j a v a . awt . ∗ ;
p u b l i c c l a s s H a l l o A p p l e t e x t e nds A p p l e t
{
public void pa i nt ( G r a phi cs g )
{
g . d r a w S t r i n g ( " H a l l o , ␣Web ! " , 2 0 , 2 0 ) ;
}
}
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Beispiel
HalloApplet.html
<!DOCTYPE HTML PUBLIC "−//W3C//DTD␣HTML␣ 4 . 0 1 ␣ T r a n s i t i o n a l //EN"
" h t t p : / /www . w3 . o r g /TR/ htm l 4 / l o o s e . dtd ">
<html>
<head>
< t i t l e>H a l l o A p p l e t</ t i t l e>
</ head>
<body b g c o l o r="LIME">
<h1>V i e r G e w i nnt</ h1>
<a p p l e t code=" H a l l o A p p l e t . c l a s s " width=" 400 " h e i g h t=" 300 ">
</ a p p l e t>
</ body>
</ html>
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Applets
Das Verhalten eines Applets steuern wir, indem wir Methoden
überladen.
void init ()
wird beim Laden des Applets aufgerufen.
wird beim Beenden des Applets aufgerufen (z.B.
beim Schließen des Browsers).
void destroy ()
void paint(Graphics) wird aufgerufen, wenn das Applet neu
gezeichnet werden soll (z.B. weil es verdeckt und nun wieder
sichtbar wurde). Das Graphics-Objekt repräsentiert die grafische
Oberfläche des Applets und kann genutzt werden, um darauf
zu zeichnen oder Text auszugeben.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Ausnahmebehandlung
Multithreading
Applets
Verarbeiten von Mauseingaben
Klassen, die das Interface MouseListener implementieren, können vom
Applet mit der Methode addMouseListener als Verarbeiter von
Mausereignissen registriert werden.
Wenn das Applet selbst dieses Interface implementiert, kann es sich
selbst registrieren.
beinhaltet Methoden wie void mouseClicked(MouseEvent),
welche aufgerufen wird, wenn ein Mausklick im Applet
stattgefunden hat. Der Parameter vom Typ MouseEvent liefert
zusätzliche Informationen, wie z.B. die Position, auf die geklickt
wurde.
MouseListener
Genauso funktionieren die Interfaces MouseMotionListener
(Mausbewegungen), MouseWheelListener (Drehen des Mausrades)
und KeyListener (Tastatureingaben).
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Vier Gewinnt: Die grafische Variante
Nun wollen wir unser Vier-Gewinnt-Spiel mit einer grafischen
Benutzerschnittstelle versehen und als Applet implementieren. Um
die Sache zu vereinfachen, lassen wir diesmal nur die Variante
„Mensch gegen Computer” zu.
Dank Objektorientierung können wir viele Klassen der textbasierten
Version wiederverwenden.
Da wir nicht das Applet blockieren dürfen, während wir auf
Mauseingaben warten, lassen wir den eigentlichen Spielablauf in
einem zweiten Thread stattfinden.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Die Klasse Spielbrett bekommt eine weitere (überladene) Methode
void anzeigen(Graphics g), welche das Spielfeld in einer Größe von
700×600 Punkten zeichnet.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Die grafische Ausgabe könnte z.B. so aussehen:
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Klasse MenschlicherSpielerGUI (abgeleitet von MenschlicherSpieler ,
implementiert MouseListener)
Eigenschaften:
int spalte speichert die Spalte, auf die der Spieler geklickt hat
bzw. -1, wenn noch kein Klick bemerkt wurde.
Methoden:
void mouseClicked(MouseEvent)
berechnet bei Mausklicks aus den
Koordinaten die Spalte.
Überschreibt die Methode ziehen von Spieler . Diese soll mit
Thread.sleep so lange warten, bis spalte nicht mehr -1 ist. Dann
soll der Wert von spalte zurückgegeben und diese Variable
wieder auf -1 gesetzt werden.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Klasse VierGewinntGUI (abgeleitet von Applet, implementiert Runnable)
Eigenschaften:
Wie VierGewinnt: Spieler [] , Spielbrett
amZug
speichert die Nummer des Spielers, der am Zug ist.
Ein Thread-Objekt
...
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Klasse VierGewinntGUI (abgeleitet von Applet, implementiert Runnable)
...
Methoden:
void init ()
void paint(Graphics)
Die Methode void run() aus dem Interface Runnable.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Die Methode VierGewinntGUI.init
Spielbrett und Spieler anlegen
amZug
initialisieren
Mit Hilfe der Methode addMouseListener die Mauseingaben des
Applets an den menschlichen Spieler weiterleiten.
Thread initialisieren und starten
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Neue Klassen und Methoden
Die Methode VierGewinntGUI.paint
Aufrufen der Methode anzeigen(Graphics) von Spielbrett
Außerdem soll unterhalb des Spielfeldes ein Text angezeigt
werden, welcher den Benutzer informiert, wer am Zug ist oder
– falls das Spiel beendet ist – wer gewonnen hat.
Die Methode VierGewinntGUI.run
Hier findet das statt, was in der ersten Vier-Gewinnt-Variante in der
Methode main getan wurde: Die Spieler werden abwechselnd nach
ihren Zügen gefragt und diese auf dem Spielbrett ausgeführt.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Neue Klassen und Methoden
Klassendiagramm
Spieler
Eigenschaften
!int meineNummer
Methoden
!void nummerZuweisen(int)
!int ziehen(Spielstand)
<<interface>>
<<interface>>
Spielstand
Runnable
Methoden
!int breite()
!int hoehe()
!int wessenStein(int, int)
Methoden
!void run()
Applet
Methoden
!void init()
!void paint(Graphics)
...
Spielbrett
ComputerSpieler
MenschlicherSpieler
Eigenschaften
???
Methoden
!int ziehen(Spielstand)
???
Methoden
!int ziehen(Spielstand)
Eigenschaften
!final int BREITE, HOEHE
!int[][] brett
Methoden
!void steinSetzen(int, int)
!boolean hatGewonnen(int)
!boolean remis()
!boolean spielBeendet()
!void anzeigen(PrintStream)
!void anzeigen(Graphics)
<<interface>>
MouseListener
MenschlicherSpielerGUI
Methoden
!void mouseClicked(MouseEvent)
Methoden
!int ziehen(Spielstand)
Jürn Laun
VierGewinntGUI
Eigenschaften
!Spieler[] spieler
!Spielbrett brett
!int amZug
!Thread spielThread
Methoden
!void init()
!void paint(Graphics)
!void run()
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Was nun?
Üben Sie! Programmieren lernen dauert (oft Jahre). Probieren
Sie aus, spielen Sie und trauen Sie sich nach und nach an
größere Projekte. Diese Phase eigentlichen Lernens kann kein
Kurs ersetzen.
Wer eine kann, kann alle: Wenn Sie die Konzepte der
objektorientierten Programmierung mit Java verstanden
haben, sollten Ihnen andere objektorientierte Sprachen keine
großen Schwierigkeiten bereiten.
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Weiter mit Java
Aber auch in Java (und dessen Dunstkreis) gibt es eine Fülle von
interessanten Technologien, die wir im Kurs nicht oder nur am
Rande behandelt haben. Schauen Sie sich zum Beispiel
Packages,
Generizität,
grafische Benutzeroberflächen (Kontrollelemente, Fenster,
AWT, Swing),
Dateiein- und ausgabe,
Netzwerk- und Internetklassen,
JavaDoc,
Anwendungen auf mobilen Geräten (Java ME) oder
UML (nicht nur Java, sondern OOP allgemein)
an!
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Danke
für’s Teilnehmen, Zuhören und Mitmachen!
Jürn Laun
Grundlagen der Programmierung
Weitere Techniken und Features von Java
Projekt (Teil II)
Ausblick
Quellen
Quellen
Sun Microsystems.
The Java Language Specification.
http://java.sun.com/docs/books/jls/index.html , 2005.
[Webseite; zuletzt abgerufen 01.03.2009].
Sun Microsystems.
Java SE 6 API Specification.
http://java.sun.com/javase/6/docs/api/ , 2008.
[Webseite; zuletzt abgerufen 01.03.2009].
Jürn Laun
Grundlagen der Programmierung