5.2 Objekte, Klassen, Kapselung
Die objektorientierte Modellierung bildet die Grundlage für die objektorientierte Implementierung eines
Systems.
Dieser Abschnitt beschäftigt sich mit der Umsetzung der vorgestellten Modellierungskonzepte in objekt- orientierte Programmiersprachen, insbesondere Java.
Überblick:
• Beschreibung von Objekten und Klassen
• Anwendung von Objekten
• Spracherweiterungen: Ausnahmebehandlung und Initialisierung
• Anwenden und Entwerfen von Klassen
• Spracherweiterungen: Überladen, Klassenattribute und Klassenmethoden
• Zusammenwirken der Spracherweiterungen
• Rekursive Klassen
• Typsystem von Java und parametrische Typen
• Kapselung und Strukturieren von Klassen
• Prototyp-Konzept:
Der Programmierer beschreibt direkt einzelne Objekte. Neue Objekte werden durch Klonen existierender Objekte und Verändern ihrer Eigenschaften zur Laufzeit erzeugt.
• Klassenkonzept:
Der Programmierer deklariert Klassen als
Beschreibung der Eigenschaften, die Objekte dieser Klasse haben sollen. Die
Programmiersprache ermöglicht es, zur
Laufzeit Objekte der Klassen zu erzeugen, aber nicht, die Klassen zu verändern.
5.2.1 Beschreibung von
Objekten und Klassen
In der objektorientierten Programmierung betrachtet man die Ausführung eines Programms als ein
System kooperierender Objekte.
Wir betrachten hier nur das Klassenkonzept.
Grundsätzlich gibt es zwei Konzepte zur program- miersprachlichen Beschreibung von Objekten:
• welche Zustände ein Objekt annehmen kann,
• auf welche Nachrichten es reagieren kann und
• wie die Methoden aussehen, mit denen ein Objekt auf den Empfang von Nachrichten reagieren kann.
Die Eigenschaften und das Verhalten eines
(programmiersprachlichen) Objekts ergeben sich aus seinen möglichen Zuständen und daraus, wie es auf Nachrichten reagiert.
Eine Objektbeschreibung - insbesondere eine Klassendeklaration - muss daher festlegen:
Die Menge der möglichen Zustände eines
Objekts entspricht den Wertebereichen seiner Attribute.
Die Reaktionen eines Objekts auf eintreffende Nachrichten legen sein dynamisches Verhalten fest.
Eine einfache Klassendeklaration in Java hat folgende Bestandteile:
Ein Java-Objekt kann genau auf die Nachrichten reagieren, für die Methoden in seiner Klasse
deklariert sind oder für die es Methoden geerbt hat (vgl. Abschnitt 5.3).
class Person { String name;
Person(String n) { this.name = n;
}
String getName() { return this.name;
} }
Attribut
Methode Konstruktor Klassenname
Deklaration von Klassen
Klassenname
Direkt hinter dem Schlüsselwort class wird der Name der Klasse angegeben. Objekt einer
Klasse K nennt man auch Instanzen oder Ausprägungen von K.
Der Klassenname wird gleichzeitig als Typname für die Objekte dieser Klasse verwendet
(Klassentyp). Er kann im Programm dann wie elementare Typen (int, float, usw.) für die Deklaration von lokalen Variablen, Parametern und Rückgabewerten verwendet werden.
Beispiel:
Person eineMethode(Person p) { ...
Person vater;
...
}
Außer den Objekten einer Klasse K gehören auch alle Objekte von Unterklassen von K zum Typ K (siehe Abschnitt 5.3).
Attribute
Innerhalb einer Klasse K können beliebig viele Attribute deklariert werden.
Für jedes in K deklarierte Attribut vom Typ T besitzen die Objekte der Klasse K eine
objektlokale Variable vom Typ T. Diese
objektlokalen Variablen nennt man häufig auch Instanzvariablen.
Die Lebensdauer der Instanzvariablen ist gleich der Lebensdauer des Objekts.
Person
name : String
Klasse:
: Person
name:
Objekt:
getName(): String
Methoden
Innerhalb der Klassendeklaration können beliebig viele Methoden deklariert werden.
Methodendeklarationen bestehen aus einer
Signatur und einem Methodenrumpf. Syntaktisch sind sie wie Prozedurdeklarationen aufgebaut.
Außer den deklarierten Parametern besitzt jede Methode m eine weiteren, sogenannten impliziten Parameter vom Typ der Klasse, in dem m
deklariert wurde. Dieser Parameter wird im Methodenrumpf mit this bezeichnet.
String getName() { return this.name; }
String getName(Person this)
hätte in der prozeduralen Programmierung also die Signatur:
Die obige Methode in Klasse Person:
Beispiel:
Konstruktoren
Konstruktoren kann man als spezielle Methoden auffassen, die die Initialisierung von Objekten beschreiben.
Sie haben den gleichen Namen wie die Klasse, in der sie deklariert sind.
Beim Start der Ausführung eines Konstruktors ist das zugehörige Objekt bereits erzeugt, seine
Attribute jedoch nur mit Standardwerten initialisiert.
Konstruktoren liefern als Ergebnis das neu erzeugte Objekt (bzw. eine Referenz darauf) zurück.
Neben den prozeduralen Anweisungen kann eine Methodenrumpf in Java:
- neue Objekte erzeugen, - auf Attribute zugreifen,
- Nachrichten an andere Objekte schicken (Methodenaufruf).
Im Allg. umfasst die Anwendung von Objekten vier Anweisungen:
- Objekterzeugung - Attributzugriff - Methodenaufruf
- Objektlöschung (in Java nicht direkt unterstützt)
5.2.2 Anwendung von Objekten
Objekte: Erzeugen und Referenzieren
Syntax in Java:
Objekte werden mit Ausdrücken folgender Form erzeugt (engl. object creation expression):
new <Konstruktorname> ( <Parameterliste> ) Semantik:
1. Erzeuge ein Objekt / eine Instanz der Klasse, der der Konstruktor gehört. Dabei werden
insbesondere die Instanzvariablen angelegt.
2. Werte die aktuellen Parameter aus.
3. Rufe den Konstruktor mit den Parametern auf.
Dieser sollte die Instanzvariablen initialisieren.
Ergebnis ist die Referenz des neu erzeugten Objekts.
Begriffsklärung: (Referenz, Verweis, Zeiger)
Eine Objektreferenz (engl. object reference) ist
eine eindeutige abstrakte Adresse oder Bezeichnung für ein Objekt. Manchmal spricht man auch von
Verweis (engl. link) oder Zeiger (engl. pointer).
Variablen speichern nicht die Objekte als Ganzes, sondern Objektreferenzen.
Die Auswertung von Ausdrücken eines Klassentyps K liefert Referenzen auf Objekte der Klasse K.
Person a,b;
a = new Person ("Klaus");
b = a; // a und b speichern dieselbe // Objektreferenz.
b.getName(); // liefert "Klaus"
Beispiel: (Objektreferenz)
Folgendes Programmfragment verdeutlicht die
Unterscheidung zwischen Objekt und Referenzen:
: Person
a:
b:
name: "Klaus"
Es gilt also: a.name == b.name
Sprechweisen & Bemerkungen:
• Häufig spricht man von Referenzen auf ein Objekt.
• Referenzen nennt man auch anonyme Namen oder Bezeichner. Eine Referenz ist ein Wert.
• Referenzen stellt man graphisch üblicherweise durch Pfeile dar. Zwei Referenzen sind gleich, wenn sie auf das gleiche Objekt zeigen.
• Die Unterscheidung Referenz / Objekt hat viele Analogien:
- Anschrift / Wohnung - Email-Adresse / Mailbox
- Telefonnummer / Telefonanschluss - Speicheradresse / Speicherzelle
class EinObjekt {
int meinAttribut;
EinObjekt( int n ) { meinAttribut = n;
} }
Beispiel: (Referenzsemantik)
Wir zeigen ein Programmbeispiel, das verdeutlicht, warum es wichtig ist, zwischen Objekten und
Referenzen zu unterscheiden:
EinObjekt a, b, c;
a = new EinObjekt(7);
b = a;
c = new EinObjekt(7);
if( a != c ) {
a.meinAttribut = 9;
}
System.out.println( b.meinAttribut );
System.out.println( c.meinAttribut );
Anwendung der Klasse EinObjekt:
Operationen auf Referenzen in Java:
• Referenzen lassen sich mit „==“ auf Gleichheit testen bzw. mit „!=“ auf Ungleichheit. Sie sind genau dann gleich, wenn sie dasselbe Objekt referenzieren.
Beispiel:
Im obigen Beispiel gilt nach der Zuweisung an c:
a == b und a != c und b != c
• Über Referenzen kann man Objekten Nachrichten schicke und auf sie zugreifen, d.h. auf ihre
Instanzvariablen.
Bemerkungen:
• Objekte können der gleichen Klasse angehören und den gleichen Zustand haben (gleich sein), aber trotzdem nicht die gleiche Identität haben und damit auch unterschiedliche Referenzen besitzen.
• Variablen von einem Klassentyp speichern
Referenzen. Wir sagen deshalb auch vereinfachend, dass eine Variable ein Objekt referenziert.
• Es ist wichtig zwischen einer Variablen und dem Objekt, dass sie referenziert zu unterscheiden!
Die null-Referenz:
Zur Initialisierung von referenzwertigen Variablen und als Dummy-Wert gibt es die Konstante null.
null gehört zu jedem Klassentyp und referenziert kein Objekt.
Der Versuch, eine Nachricht an null zu schicken, oder auf eine Instanzvariable von null
zuzugreifen, führt in Java zu einer NullPointer- Ausnahme.
Person a,b;
a = new Person ("Klaus");
b = null; // zulässig
if( a != b ) { // Vergleich ok String s;
s = b.name; // NullPointerException b.getName(); // NullPointerException }
Beispiel: (Objektreferenz)
Folgendes Programmfragment verdeutlicht die
Unterscheidung zwischen Objekt und Referenzen:
Begriffsklärung: (Objektgeflecht)
Eine Menge von Objekten, die sich gegenseitig referenzieren, nennen wir ein Objektgeflecht (vgl. Folie 345).
Bemerkung:
• Objektgeflechte werden zur Laufzeit aufgebaut und verändert, sind also dynamische Entitäten.
• Klassendiagramme kann man als vereinfachte statische Approximationen von Objektgeflechten verstehen.
Lebensdauer von Objekten und Instanzvariablen:
In Java lassen sich Objekte nicht löschen.
Aus Sicht des Programmierers leben Objekte und deren Instanzvariablen von der Objekterzeugung bis zum Ende der Ausführung des Programms.
Der Speicher nicht erreichbarer Objekte wird ggf.
vor Ablauf der Lebensdauer von der automatischen Speicherbereinigung frei gegeben (vgl. Folien 392ff).
Attributzugriff
Syntax in Java:
Auf Instanzvariablen von Objekten kann mit
Ausdrücken folgender Form zugegriffen werden:
<referenzwertiger Ausdruck>.<Attributbezeichner>
Semantik:
Werte den referenzwertigen Ausdruck aus. Liefert dieser null, löse eine NullPointerException aus.
Andernfalls liefert er die Referenz auf ein Objekt X;
in dem Fall liefert der gesamte Ausdruck die
Instanzvariable von X zum angegenen Attribut (L- Wert) oder deren Wert (R-Wert).
Abkürzende Notation:
Der implizite Methodenparameter this kann beim Zugriff auf eine Attribut a weggelassen werden, d.h.
a
ist gleichbedeutend mit this.a
innerhalb von Klassen, in denen a deklariert ist.
Beispiel: (Attributzugriffe)
class DeinObjekt { MeinObjekt du;
String deinName;
}
class MeinObjekt {
boolean binEingetragen;
String meinName;
void dichInit (DeinObjekt d) {
System.out.println( d.deinName );
d.deinName = this.meinName;
this.binEingetragen = true;
meinName = d.du.meinName;
} }
Methodenaufruf: (engl. method invocation)
Syntax:
Ein Methodenaufruf ist ein Ausdruck ähnlich einem Prozeduraufruf, allerdings mit einem zusätzlichen Parameter:
<refwertigerAusdruck>.<Methodenbezeichner> (
<AktuelleParameterliste> ) Semantik:
Werte den referenzwertigen Ausdruck aus. Liefert dieser null, löse eine NullPointerException aus.
Andernfalls liefert er die Referenz auf ein Objekt X.
Werte die aktuellen Parameter p1, ..., pn aus.
Führe den Rumpf der angegebenen Methode mit - X als implizitem Parameter und
- p1, ... , pn als expliziten Parametern aus.
Das Ergebnis des Aufrufs ist der Rückgabewert der Ausführung des entsprechenden Methodenrumpfes.
Bemerkung:
Eine verfeinerte Semantik wird in 5.3 behandelt.
Dabei wird auch der Zusammenhang zum Senden von Nachrichten angesprochen.
Beispiel: (Methodenaufrufe)
class Mensch {
Mensch vater, mutter;
String name;
Mensch getOpa (boolean mutterseits) { if ( mutterseits ) {
return mutter.vater;
} else {
return vater.vater;
} }
void eineMethode (Mensch m) { Mensch opaV;
String opaMName;
opaV = m.getOpa(false);
opaMName = m.getOpa(true). name;
} ...
}
Abkürzende Notation:
Wie beim Attributzugriff kann auch beim Methoden- aufruf der implizite Methodenparameter this weg-
gelassen werden, also m(...) statt this.m(...) .
Objektorientierte Programme
Ein objektorientiertes Java-Programm besteht aus einer Menge von Klassen. Mindestens eine der
Klassen muss eine Methode mit Namen main und folgender Signatur besitzen:
public static void main ( String[] args ) {
...
}
Beim Start von wird die Klasse angegeben, deren main-Methode ausgeführt werden soll:
java <Klassenname> <arg1> <arg2> ...
Die Argumente arg1,... werden dabei im Parameter args als ein Feld von Strings übergeben.
Bei der Ausführung werden die benötigten Objekte erzeugt. Diese Bearbeiten ihre Aufträge durch
Ausführung von Methoden.
Initialisierung
Attribute und lokale Variablen können direkt an ihrer Deklarationsstelle initialisiert werden.
Somit sind folgende Programmstücke gleichbedeutend.
float pi;
pi = 3.141;
float pi = 3.141;
In Java können Attribute und Variablen durch das Schlüsselwort final als unveränderlich
deklariert werden.
In diesem Fall muss die Initialisierung an der Deklarationsstelle erfolgen.
class Mathe { ...
final float pi = 3.141; // Konstante ...
}
Die Initialisierung von Attributen erfolgt vor dem Eintritt in den Konstruktorrumpf.
5.2.3 Spracherweiterungen: Initialisierung
und Ausnahmebehandlung
Beispiel: (Initialisieren von Attributen)
Folgendes Programm mit Initialisierung
class C {
int ax = 7, ay = 9;
C(){
m();
}
void m(){
int v1 = 4848, v2 = -3; ...
} }
ist äquivalent zu folgendem Programm
class C {
int ax, ay;
C(){
ax = 7;
ay = 9;
m();
}
void m(){
int v1, v2;
v1 = 4848; v2 = -3; ...
} }
Ausnahmebehandlung
Wie in 3.4.1., Folie 235, bereits angesprochen, kann die Auswertung eines Ausdrucks bzw.
die Ausführung einer Anweisung:
- normal terminieren
- in eine Ausnahmesituation kommen und abrupt terminieren
- nicht terminieren
Es gibt drei Arten von Ausnahmesituationen:
1. Vom Programmierer schwer zu kontrollierende
und zu beseitigende Situtationen (Speichermangel) 2. Programmierfehler (Nulldereferenzierung, Verlet-
zung von Indexgrenzen
3. Zeitweise nicht verfügbare Ressourcen, anwen- dungsspezifische Ausnahmen, die behebbar sind.
Ausnahmesituationen werden in Programmier- sprachen unterschiedlich behandelt:
- Programmabbruch (engl. abortion) - Ausnahmebehandlung
Auslösen von Ausnahmen:
Das Auslösen einer Ausnahme kann
- sprachdefiniert (z.B. NullPointer, IndexOutOfBounds) - oder durch eine Anweisung spezifiziert sein.
In Java gibt es zum Auslösen von Ausnahmen die throw-Anweisung.
Syntax:
Die throw-Anweisung hat die Form:
throw <Ausdruck>;
wobei der Ausdruck ein Ausnahmeobjekt als Ergebnis liefern muss. (Die throw-Anweisung entspricht dem raise-Ausdruck in ML.)
Java bietet Sprachmittel für die Ausnahme- behandlung (engl. exception handling).
Dabei spielen drei Fragen eine Rolle:
1. Wann/wie werden Ausnahmen ausgelöst?
2. Wie kann man sie abfangen?
3. Wie kann man neue Ausnahmetypen deklarieren?
void myMethod (String[] sfeld) {
try {
myPrint( sfeld[0] );
myPrint( sfeld[1] );
} catch (NullPointerException e) { myPrintln("sfeld is null");
} catch (IndexOutOfBoundsException e){
myPrintln("sfeld too small");
} }
Abfangen von Ausnahmen:
Die try-catch-Anweisung dient dem Abfangen und Behandeln von Ausnahmen (entspricht dem handle-Ausdruck in ML):
Semantik:
Werte den Ausdruck aus.
Löst die Auswertung eine Ausnahme aus, ist dies die Ausnahme, die von der Anweisung ausgelöst wird.
Andernfalls löse die Ausnahme aus, die das Ergebnis des Ausdrucks ist.
Bemerkung:
Java verlangt die Deklaration derjenigen Ausnahme- typen in der Signatur einer Methoden m, die nicht von m abgefangen werden (Genaueres in 5.3).
Beispiel:
int m( int i ) throws SomeException { if( i<0 ){
throw new SomeException();
} ...
}
Die Deklaration von Exception-Klassen behandeln wir in Abschnitt 5.3.
Benutzerdefinierte Ausnahmetypen:
Tritt eine Ausnahme vom Typ A im try-Block auf, wird ein A-Objekt X erzeugt.
Ist der Typ A in der Liste der catch-Klauseln aufgeführt, - wird die Ausnahme gefangen,
- X an den Bezeichner der entsprechenden catch- Klausel gebunden und
- diese catch-Klausel ausgeführt (Verfeinerung in 5.3).
Beispiel: (Ausnahmebehandlung)
class Try {
public static void main( String[] argf ){
long maxint = 2147483647L;
try{
int m, n, ergebnis = 0 ;
m = Integer.parseInt( argf[0] );
n = Integer.parseInt( argf[1] );
long aux = (long)m + (long)n;
if( aux > maxint ) throw new Ueberlauf();
ergebnis = (int)aux ;
} catch ( IndexOutOfBoundsException e ) { System.out.println("Falsche Argumente");
} catch ( NumberFormatException e ) { System.out.println(
"Element in argf keine int-Konstante");
} catch ( Ueberlauf e ) {
System.out.println("Ueberlauf");
} }
Klassen bilden das zentrale Sprachkonstrukt von Java.
Dementsprechend stehen beim Programmentwurf zwei Fragen im Mittelpunkt:
• Welche existierenden Klassen können für den Programmentwurf herangezogen werden?
• Welche Klassen müssen neu entworfen werden?
Zur Diskussion dieser Aspekte betrachten wir ein kleines Beispiel.
Aufgabenstellung:
Ein rudimentäres Browser-Programm soll realisiert werden, mit dem einfache W3Seiten bei einem Server geholt und in einem Fenster angezeigt werden können.
Wir gehen davon aus, dass die folgenden Klassen existieren:
- W3Seite: Implementiert W3Seiten.
- W3Server: Implementiert W3Server bzw. ihre Schnittstelle.
- Textfenster: Kann W3-Seiten anzeigen.
5.2.4 Anwenden und Entwerfen von Klassen
W3Server Browser
Textfenster
1..
1
Klassendiagramm zur Lösung der Aufgabenstellung:
*
ablegen(String,W3Seite) W3Seite holen(String)
anzeigen(...)
* *
W3Seite
String getTitel() String getInhalt()
*
1
Schnittstellen der gegebenen Klassen:
class W3Server {
W3Server() { ... }
void ablegenSeite( String adr, W3Seite s ){
...
}
W3Seite holenSeite( String adr ) { ... } }
class TextFenster ... { ...
TextFenster() { ... }
void anzeigen(String tzeile,String text){
...
} }
laden(...)
aktSeite: W3Seite
/**
* Objekte repräsentieren triviale
* Web-Seiten mit Titelzeile und Inhalt
*/
class W3Seite {
String titel;
String inhalt;
W3Seite ( String t, String i ) { titel = t;
this.inhalt = i;
}
String getTitel() { return this.titel;
}
String getInhalt() { return inhalt;
} }
Die vollständige Klasse W3Seiten:
class Browser {
W3Server meinServer;
TextFenster oberfl;
W3Seite aktSeite; // aktuelle Seite Browser( W3Server server ){
meinServer = server;
oberfl = new TextFenster();
laden( new W3Seite("Startseite",
"NetzSurfer: Keiner ist kleiner") );
interaktiveSteuerung();
}
void laden( W3Seite s ){
aktSeite = s;
oberfl.anzeigen( aktSeite.getTitel(), aktSeite.getInhalt());
}
void interaktiveSteuerung() { ... } }
Wichtige Implementierungsteile einer rudimentären Browser-Klasse:
In Java ist es erlaubt, innerhalb einer Klasse mehrere Methoden mit dem gleichen Namen zu deklarieren, d.h. es gibt zwei Bindungen mit gleichem Namen.
Eine derartige Mehrfachverwendung nennt man Überladen eines Namens. Methoden mit gleichen
Namen müssen sich in der Anzahl oder in den Typen der Parameter unterscheiden.
Durch die unterschiedliche Signatur kann der
Übersetzer die Überladung auflösen, d.h. für jede Aufrufstelle ermitteln, welche von den Methoden gleichen Namens an der Aufrufstelle gemeint ist.
Entsprechend dem Überladen von Methodennamen erlaubt Java auch das Überladen bei Konstruktoren.
5.2.5 Spracherweiterungen: Überladen, Klassenvariablen und -methoden
Überladen
Beispiel
:(Überladen)
Die Java-Bibliothek bietet viele Beispiele für Überladung. Wir betrachten die Klasse String (hier nur unvollständig wiedergegeben):
class String {
/** The value is used for character storage */
char[] value;
/** The offset is the first index of the used storage*/
int offset;
/** The count is the number of characters in the ... */
int count;
String() { value = new char[0]; } String( String value ) { ... } String( char[] value ) {
this.count = value.length;
this.value = new char[count];
System.arraycopy(value,0,this.value,0,count);
} ...
int indexOf(int ch) { return indexOf(ch, 0);}
int indexOf(int ch, int fromIndex) { ... } int indexOf(String str) { ...}
int indexOf(String str, int fromIndex) {...}
int length() { return count; } char charAt(int index) {
if ((index < 0) || (index >= count)) { throw
new StringIndexOutOfBoundsException(index);
}
return value[index + offset];
} }
Klassenattribute und Klassenmethoden
Die Deklaration eines Klassenattributs liefert eine klassenlokale Variable. Syntax:
static <Typausdruck> <Attributname> ; Klassenattribute/-variablen werden häufig auch als statische Attribute/Variablen bezeichnet.
Die Variable kann innerhalb der Klasse mit dem Attributnamen, außerhalb mittels
<Klassenname> . <Attributname>
angesprochen werden. Die Lebensdauer der Variablen entspricht der Lebensdauer der Klasse.
Bemerkung:
Klassenvariablen verhalten sich ähnlich wie globale Variablen in der prozeduralen Programmierung.
Beispiel: (Klassenattribut)
class InstanceCount {
static int instCount = 0;
InstanceCount(){
instCount++;
...
} ...
}
Die Deklaration einer Klassenmethode entspricht der Deklaration einer Prozedur. Klassenmethoden besitzen keinen impliziten Parameter. Sie können nur auf Klassenattribute, Parameter und lokale Variable zugreifen. Syntax:
static <Methodendeklaration>
Klassenmethoden werden häufig auch als statische Methoden bezeichnet.
Klassenmethoden werden mit folgender Syntax aufgerufen:
<Klassenname> . <Methodenname> ( ... )
Innerhalb der Klasse kann der Klassenname entfallen.
Beispiel: (Klassen-, statische Methoden)
Deklaration:
class String { ...
static String valueOf( long l ) { ... } static String valueOf( float f ) { ... } ...
}
Anwendung/Aufruf:
String.valueOf( (float)(7./9.) )
liefert die Zeichenreihe: "0.7777778"
Bemerkung:
In Kapitel 4 wurden Klassenmethoden zur
prozeduralen Programmierung in Java genutzt.
class System {
final static InputStream in = ...;
final static PrintStream out = ...;
static void exit(int status) { ... } static native void arraycopy(
Object src,int src_position,
Object dst,int dst_position, int length);
}
Die Klasse PrintStream besitzt Methoden print und println:
System.out.print("Das klaert die Syntax");
System.out.println(" von Printaufrufen");
Beispiele: (Klassenattribute u. -methoden)
1. Charakteristische Beispiele für Klassenattribute und -methoden liefert die Klasse System, die eine Schnitt- stelle von Programmen zur Umgebung bereitstellt:
2. Unsere Klasse InputOutput liefert auch schöne Beispiele für statische Methoden und Überladung:
public class InputOutput {
public static int readInt(){...}
public static String readString(){...}
public static char readChar(){...}
public static void print(int i){
System.out.print(i);
}
public static void println(int i){
System.out.println(i);
}
public static void print(char c){
System.out.print(c);
}
public static void println(char c){
System.out.println(c);
}
public static void print(String s){
System.out.print(s);
}
public static void println(String s){
System.out.println(s);
} }
5.2.6 Zusammenwirken der Spracherweiterungen
Das Zusammenwirken der eingeführten Sprach-
elemente erlaubt bereits, recht komplexe Programme zu schreiben.
Folgendes Programmbeispiel mischt prozedurale und objektorientierte Sprachelemente. Es dient zum Studium des Zusammenwirkens der
Spracherweiterungen.
Beispiel: (Zusammenwirken von Sprachel.)
Wir erweitern das Browserbeispiel von 5.2.4:
- Unterstützung mehrerer Browserfenster - Interaktive Steuerung über die Konsole
class Konsole {
static String readString() { ... }
static void writeString( String s ) {...}
}
Entwurf der Implementierung:
- Die gemeinsamen Teile aller Browserfenster werden durch Klassenattribute und –methoden realisiert.
- Es gibt zwei Konstruktoren: Einer startet das erste Browserobjekt; der andere weitere
Browserobjekte.
- Die gemeinsamen Teile der Konstruktoren werden von der Methode initialisieren erledigt.
- Die interaktive Steuerung von der Konsole
wird durch eine statische Methode implementiert.
- Zur einfacheren Handhabung steht eine
Klassenmethode start zur Verfügung, die den W3Server als Argument bekommt:
...
Browser.start( testServer );
...
- Die Browserfenster werden in einem Feld auf Klassenebene verwaltet.
class Browser {
TextFenster oberfl;
W3Seite aktSeite;
static W3Server meinServer;
static final int MAX_ANZAHL = 4;
static Browser[] gestarteteBrowser =
new Browser[MAX_ANZAHL];
static int naechsterFreierIndex = 0;
static int aktBrowserIndex;
static W3Seite startseite = new W3Seite("Startseite",
"NetzSurfer: Keiner ist kleiner");
// Konstruktor für ersten Browsers Browser( W3Server server ) {
if( naechsterFreierIndex != 0 ) {
System.out.println("Browser gestartet");
} else {
meinServer = server;
initialisieren();
} }
// Konstruktor für weiterere Browserfenster Browser() {
if( naechsterFreierIndex == MAX_ANZAHL ) { System.out.print("Maximale Anzahl ");
System.out.println(" Browser erreicht");
} else {
initialisieren();
} }
static void start( W3Server server ) { new Browser(server);
Browser.interaktiveSteuerung();
}
void initialisieren() {
oberfl = new TextFenster();
gestarteteBrowser[ naechsterFreierIndex ]
= this;
aktBrowserIndex = naechsterFreierIndex;
naechsterFreierIndex++ ; laden( startseite );
}
void laden( W3Seite s ){
aktSeite = s;
oberfl.anzeigen(aktSeite.getTitel(), aktSeite.getInhalt());
}
static void interaktiveSteuerung() { char steuerzeichen = '0';
do {
Konsole.writeString("Steuerzeichen [lnwe]: ");
try {
String eingabe = Konsole.readString();
if( eingabe.equals("") ) steuerzeichen = '0';
else
steuerzeichen = eingabe.charAt(0);
} catch( Exception e ) { System.exit( 0 );
}
switch( steuerzeichen ){
case 'l':
String seitenadr;
Konsole.writeString("Seitenadresse: ");
seitenadr = Konsole.readString();
gestarteteBrowser[aktBrowserIndex] .
laden( meinServer.holenSeite( seitenadr ) );
break;
case 'n': new Browser(); break;
case 'w':
aktBrowserIndex =
(aktBrowserIndex+1) % naechsterFreierIndex;
break;
case 'e':
System.exit( 0 );
default:
Konsole.writeString("falsche Eingabe\n");
}
} while( true );
} }
5.2.7 Rekursive Klassen
Definition: (rekursive Klassendeklarationen)
Eine Klassendeklaration K heißt direkt rekursiv, wenn Attribute von K den Typ K haben.
Eine Menge von Klassendeklarationen heißt verschränkt rekursiv oder indirekt rekursiv
(engl. mutually recursive), wenn die Deklarationen gegenseitig voneinander abhängen.
Eine Klassendeklaration heißt rekursiv, wenn sie direkt rekursiv ist oder Element einer Menge verschränkt rekursiver Klassendeklarationen ist.
Bemerkung:
• Wir identifizieren Klassen mit ihren Deklarationen.
• Wichtige Anwendung rekursiver Klassen ist die Implementierung von Listen-, Baum- und Graph- strukturen.
Im Folgenden betrachten wir rekursive Klassen
für Listen. Dabei variieren wir die Programmierstile und die bereitgestellten Schnittstellen.
Implementierung von Listen
Beispiel: (Einfachverkettete Listen)
class ProcList { int head;
ProcList tail;
}
Bei einfachverketteten Listen gibt es für jedes
Listenelement ein Objekt mit zwei Instanzvariablen:
- zum Speichern des Elements
- zum Speichern der Referenz auf den Rest der Liste.
: ProcList head: 6
tail:
: ProcList : ProcList head: -3
tail:
head: 84 tail:
Prozedurale Datenstrukturen:
In der prozeduralen Programmierung sind
Datentypen und Prozeduren zunächst getrennt (Zusammenfassung erst auf Modulebene).
class ProcListMain {
static boolean sortiert(ProcList l){
if( l == null || l.tail == null ) { return true;
} else if( l.head <= l.tail.head ){
return sortiert( l.tail );
} else {
return false;
} }
public static void main( String[] argf ){
ProcList l1 = new ProcList();
ProcList l2 = new ProcList();
ProcList l3 = new ProcList();
l1.head = 1;
l2.head = 2;
l3.head = 3;
l1.tail = l2;
l2.tail = l3;
l3.tail = null;
System.out.println( sortiert(l1) );
l3.head = 0;
System.out.println( sortiert(l1) );
} }
Diskussion:
Die prozedurale Fassung erlaubt es jedem, der eine Referenz auf ein Listenknoten hat, das Objektgeflecht unkontrolliert zu verändern.
Zum Beispiel könnte man Listen in ein zyklisches Geflecht verändern und damit Invarianten
verletzen.
Funktionale Datenstrukturen:
Unterbindet man den beliebigen Zugriff auf die Attribute und bietet nur Methoden an, um Listen auf- und abzubauen, kann man ein
Verhalten wie in der funktionalen Programmierung erreichen.
Das Mehr an Garantien wird durch weniger
Flexibilität bezahlt. Insbesondere ist das direkte Einfügen und Modifizieren in der „Mitte“ einer Datenstruktur nicht mehr möglich.
Beispiel: (Zugriff nur über Methoden)
class FunctionalList { private int head;
private FunctionalList tail;
static FunctionalList empty() { return new FunctionalList();
}
boolean isempty(){
return tail == null;
}
int head(){
if( isempty() ){
throw new NoSuchElementException();
}
return head;
}
FunctionalList tail(){
if( isempty() ){
throw new NoSuchElementException();
}
return tail;
}
FunctionalList cons( int i ) {
FunctionalList aux = new FunctionalList();
aux.head = i;
aux.tail = this;
return aux;
} }
class FunctionalListMain {
static boolean sortiert( FunctionalList l ){
if( l.isempty() || l.tail().isempty() ) { return true;
} else if( l.head() <= l.tail().head() ){
return sortiert( l.tail() );
} else {
return false;
} }
public static void main( String[] argf ){
FunctionalList le, l1, l2, l3;
le = FunctionalList.empty();
l3 = le.cons(3);
l2 = l3.cons(2);
l1 = l2.cons(1);
System.out.println( sortiert(l1) );
l1 = l3.cons(4);
System.out.println( sortiert(l1) );
} }
Objektorientierte Listen:
Aus objektorientierter Sicht ist eine Liste ein Behälter, in den man etwas hineintun und aus dem man etwas herausnehmen kann:
Beispiel: (Liste als Behälter)
class SLinkedList {
// Liefert das erste Element der Liste, // ohne diese Liste zu veraendern
int getFirst(){ ... }
// Fügt vorne ein neues Element an diese // Liste an
void addFirst( int n ) { ... }
// Löscht das erste Element dieser Liste // und liefert es als Ergebnis
int removeFirst() { ... }
// Liefert die Elementanzahl dieser Liste int size() { ... }
}
class SLinkedListMain {
public static void main( String[] argf ){
SLinkedList l = new SLinkedList();
l.addFirst(3);
l.addFirst(2);
l.addFirst(1);
System.out.println( l.removeFirst() );
System.out.println( l.size() );
System.out.println( l.removeFirst() );
}
Zunächst die Schnittstelle und Anwendung der Klasse:
Und nun Teile der Implementierung von SLinkedList:
import java.util.NoSuchElementException;
class SEntry { int head;
SEntry tail;
}
class SLinkedList {
private SEntry entries = null;
private int size = 0;
int getFirst(){
if( size == 0 ){
throw new NoSuchElementException();
}
return entries.head;
}
void addFirst( int n ) { size++;
SEntry auxe = new SEntry();
auxe.head = n;
auxe.tail = entries;
entries = auxe;
} ...
}
: Entry element:
next:
:LinkedList header:
size: 3
previous:
: Entry element:
next:
previous:
: Entry element:
next:
previous:
: Entry element:
next:
previous:
Problem bei der erläuterten Implementierung:
Rekursives oder iteratives Durchlaufen durch die Liste ist nicht möglich (Abhilfe: s.u.).
Andere Formen von Listenimplementierungen
speichern die Elemente in Feldern oder nutzen eine doppelte Verkettung der Eintragsknoten:
... ... ...
Implementierung von Bäumen
Binäre Bäume sind wichtige Datenstrukturen, z.B.
zur Darstellung von Mengen.
class BinTree {
private int elem;
private BinTree left, right;
BinTree( int e ) { elem = e;
}
void sorted_insert( int e ) { if( e < elem ) {
if( left == null ) { left = new BinTree(e);
} else {
left.sorted_insert(e);
}
} else if( elem < e ) { if( right == null ) {
right = new BinTree(e);
} else {
right.sorted_insert(e);
} } }
// weiter auf nächster Folie
Beispiel: (Bäume)
boolean contains( int e ) {
if( e < elem && left != null ) { return left.contains(e);
} else if( elem > e && right != null ) { return right.contains(e);
} else {
return e==elem;
} }
void printTree() {
if( left != null ) left.printTree();
System.out.println(elem);
if( right != null ) right.printTree();
} }
class BinTreeMain {
public static void main( String[] argf ){
BinTree bt = new BinTree(12);
bt.sorted_insert(3);
bt.sorted_insert(12);
bt.sorted_insert(11);
bt.sorted_insert(12343);
bt.sorted_insert(-2343);
bt.sorted_insert(233);
bt.printTree();
} }
Iteratoren
Iteratoren erlauben es, schrittweise über Behälter- Datenstrukturen zu laufen, so dass alle Elemente der Reihe nach besucht werden. Im Zusammenhang mit Kapselung (s.u.) sind sie unverzichtbar.
Beispiel: (Iteratoren)
Wir reichern die Klasse SLinkedList mit Iteratoren an und zeigen deren Anwendung.
class Iterator { SEntry current;
Iterator( SEntry se ) { current = se;
}
boolean hasNext() {
return current!=null;
}
int next() {
if( current==null ){
throw new NoSuchElementException();
}
int res = current.head;
current = current.tail;
return res;
}
class SLinkedList {
private SEntry entries = null;
...
Iterator iterator() {
return new Iterator( entries );
} }
class SLinkedListMain {
public static void main( String[] argf ){
SLinkedList l = new SLinkedList();
l.addFirst(3);
l.addFirst(2);
l.addFirst(4);
Iterator iter = l.iterator();
while( iter.hasNext() ) {
System.out.println( iter.next() );
} } }
Bemerkung:
Der Iterator muss Zugriff auf die interne Repräsentation der Datenstruktur haben, über die er iteriert.
5.2.8 Typsystem von Java und parametrische Typen
Werte in Java sind
- die Elemente der elementaren Datentypen, - Referenzen auf Objekte,
- der Wert null.
Jeder Wert in Java gehört zu mindestens einem Typ.
Vordefinierte und benutzerdeklarierte Typen sind - die vordefinierten elementaren Typen,
- die durch Klassen deklarierten Typen,
- die durch Schnittstellen deklarierten Typen (s.u.).
Implizit deklariert sind die Feldtypen zu den Klassen- und Schnittstellentypen (Typkonstruktor „[]“ ).
Feld-, Klassen- und Schnittstellentypen fasst man unter dem Namen Referenztypen zusammen.
(null gehört zu allen Referenztypen.)
Klassen- und Schnittstellentypen beschreiben, welche Nachrichten ihre Objekte verstehen bzw. welche
Methoden sie besitzen.
Typsystem von Java
Bemerkung:
In typisierten objektorientierten Sprachen können Werte zu mehreren Typen gehören (Subtypen).
Parametrische Typen
Auch objektorientierte Sprachen unterstützen
parametrische Typsysteme wie in ML. Für Java ist eine derartige Unterstützung ab Version 1.5
verfügbar.
Wir betrachten eine parametrische Fassung der Klasse SLinkedList:
Beispiel: (Parametrische Typen)
class SLinkedList<A> { A getFirst(){ ... }
void addFirst( A n ) { ... } A removeFirst() { ... }
int size() { ... } }
class Test {
public static void main( String[] argf ){
SLinkedList<String> l1
= new SLinkedList<String>();
l1.addFirst("Die Ersten werden");
l1.addFirst("die Letzten sein");
int i = l1.getFirst().indexOf("sein");
// liefert 13 SLinkedList<W3Seite> l2
= new SLinkedList<W3Seite>();
l2.addFirst(new W3Seite("Titel","Inhalt"));
l2.addFirst(new W3Seite("Title","Content"));
int i = l2.getFirst().indexOf("sein");
// liefert Übersetzungsfehler }
}
In Java 5 ist die Instanzierung der Typ-
Parameter nur durch Referenztypen gestattet:
5.2.9 Kapselung und Strukturieren von Klassen
Zwei Aspekte zur weiteren Strukturierung objektorientierter Programme:
- Schnittstellenbildung und Kapselung - Schachtelung von Klassen und Pakete
Schnittstellenbildung und Kapselung
Objekte stellen eine bestimmte Funktionalität bzw.
bestimmte Dienste zur Verfügung:
- Anwendersicht: Nachrichten schicken, Ergebnisse empfangen.
- Implementierungssicht: Realisierung der Zustände und Funktionalität durch
objektlokale Attribute,
Referenzen auf andere Objekte,
Implementierung von Methoden.
Ziel:
- Lege die Anwendungsschnittstelle genau fest.
- Verhindere Zugriff „von außen“ auf Implemen-
tierungsteile, die nur für internen Gebrauch bestimmt
Begriffsklärung: (Anwendungsschnittstelle)
Die Anwendungsschnittstelle eines Objekts bzw.
eines Referenztyps besteht aus
- den Nachrichten, die es für Anwender zur Verfügung stellt;
- den Attributen, die für den direkten Zugriff von Anwendern bestimmt sind.
Bemerkung:
• Die Festlegung von Anwendungsschnittstellen ist eine Entwurfsentscheidung.
• Direkter Zugriff auf Attribute muss nicht gewährt werden, sondern kann mit Nachrichten/Methoden realisiert werden.
Beispiel:
class MitDirektemAttributZugriff { public int attr;
}
class AttributZugriffueberMethoden { private int attr;
int getAttr() { return attr; }
void setAttr( int a ) { attr = a; } }
Gründe für Information Hiding:
• Vermeiden unsachgemäßer Anwendung
• Vereinfachen von Software durch Reduktion der Abhängigkeiten zwischen ihren Teilen
• Austausch von Implementierungsteilen
Begriffsklärung: (Information Hiding)
Das Prinzip des Information Hiding (deutsch meist Geheimnisprinzip) besagt, dass
- Anwendern nur die Informationen zur Verfügung stehen sollen, die zur Anwendungsschnittstelle gehören,
- alle anderen Informationen und Implementierungs- details für ihn verborgen und möglichst nicht
zugreifbar sind.
Javas Sprachmittel für Information Hiding:
Java ermöglicht es für Programmelemente sogenannte Zugriffsbereiche zu deklarieren.
Vereinfachend gesagt, kann ein Programmelement nur innerhalb seines Zugriffsbereichs verwendet werden.
Java unterscheidet vier Arten von Zugriffsbereichen:
- nur innerhalb der eigenen Klasse (Modifikator private)
- nur innerhalb der eigenen Pakets (ohne Modifikator) - nur innerhalb des eigenen Pakets und in Subklassen
(Modifikator protected)
- ohne Zugriffsbeschränkung (Modifikator public) Generell können Klassen, Attribute, Methoden und Konstruktoren mit den Zugriffsmodifikatoren deklariert werden.
Beispiel: (Vermeiden falscher Anwendung)
public class SLinkedList {
private SEntry entries = null;
private int size = 0;
public int getFirst(){ ... } ...
}
Außerhalb der Klasse SLinkedList kann das
Attribut size nicht mehr verändert werden, so dass inkonsistente Zustände, in denen size nicht die Anzahl der Elemente enthält, vermieden werden können.
Beispiel: (Austausch von Implementierungen)
public class W3Seite {
private String titel;
private String inhalt;
public W3Seite ( String t, String i ) { titel = t;
inhalt = i;
}
public String getTitel() { return titel; } public String getInhalt(){ return inhalt;}
}
Die obige Klasse kann ersetzt werden durch die folgende, ohne dass Anwender der Klasse davon tangiert werden:
public class W3Seite { private String seite;
public W3Seite( String t, String i ) {
seite = "<TITLE>" + t + "</TITLE>" + i ; }
public String getTitel(){
int ix = seite.indexOf("</TITLE>")-7;
return new String(seite.toCharArray(),7,ix);
}
public String getInhalt(){
int ix = seite.indexOf("</TITLE>") + 8;
return new String( seite.toCharArray(), ix, seite.length() – ix );
}
Wir verstehen unter Kapselung eine verschärfte Form des Information Hiding, die es dem Anwender unmöglich macht, auf interne Eigenschaften
gekapselter Objekte zuzugreifen.
Bemerkung:
• Information Hiding erlaubt insbesondere:
- konsistente Namensänderungen in versteckten Implementierungsteilen.
- Verändern versteckter Implementierungsteile, soweit sie keine Auswirkungen auf die öffentliche Funktionalität haben (kritisch).
Beispiel:
Die zweite Implementierung von W3Seite kann nur dann anstelle der ersten benutzt werden, wenn Titel die Zeichenreihe "</TITLE>" nicht enthalten.
• Attribute sollten tendenziell privat sein und nur in Ausnahmefällen öffentlich.
Begriffsklärung: (Kapselung)
Bemerkung:
• Die Verwendung von „private“ führt nicht automatisch zur Kapselung.
• Um Kapselung zu erreichen, bedarf es im Allg.
eines Zusammenwirkens unterschiedlicher Sprachmittel und Programmiertechniken.
Beispiel: (zur Kapselung)
1. Der private Zugriffsbereich bezieht sich auf die Klasse und im Allg. nicht auf einzelne Objekte:
public class FamilienMitglied { private int a;
private FamilienMitglied geschwister;
public void incrA(){
a++;
geschwister.a++;
} }
Die Methode incrA modifiziert nicht nur das Objekt, auf dem sie aufgerufen wurde, sondern auch das private Attribut a des Geschwisterobjekts.
2. Wenn Objekte andere Objekte zur Realisierung ihrer Funktionalität nutzen, müssen sie die
Kontrolle über diese Objekte behalten:
public class MyFaultyString { private char[] value;
public MyFaultyString( String s ) { value = s.toCharArray();
}
//...
public char[] toCharArray() { return value;
} }
public class Main {
public static void main( String[] args ) { MyFaultyString mfs =
new MyFaultyString("Staatssicherheit");
char[] inhalt = mfs.toCharArray();
// ... später im Programm:
inhalt[3] = 't';
inhalt[5] = ' ';
inhalt[6] = 'S';
// mfs noch unverändert?
System.out.println( mfs.toCharArray() );
} }
Es reicht also im Allg. nicht, die Attribute als privat zu deklarieren, um Kapselung zu erreichen. Es muss auch verhindert werden, dass Referenzen auf interne Objekte herausgegeben werden.
Schachtelung von Klassen und Pakete
Java-Quellprogramme bestehen aus
Typdeklarationen, d.h. Klassen- und Schnittstellen- deklarationen (s.u.). Es gibt drei Sprachkonstrukte zur Strukturierung der Typdeklarationen:
- Schachtelung von Klassen
- Gruppierung von Klassen zu Übersetzungseinheiten - Gruppierung von Übersetzungseinheiten zu Paketen Übersetzungseinheiten entsprechen einer Datei und können mehrere Typdeklarationen zusammenfassen, wobei maximal eine öffentlich sein darf.
Syntax:
package <Paketname>;
<Liste von import-Anweisungen>
<Liste von Typdeklarationen>
Ausführbare Java-Programme sind Ansammlungen von übersetzten Typdeklarationen. Die Gruppierung in Übersetzungseinheiten und die Schachtelung von Klassendeklarationen existiert auf der Ebene nicht mehr.
Schachtelung von Klassen:
Klassen integrieren zwei Aufgaben:
- Sie beschreiben Objekte (Typaspekt).
- Sie gruppieren Daten und Methoden, bilden einen Gültigkeitsbereich und unterstützen Information Hiding (Modulaspekt).
Mehrere objektorientierte Sprachen verstärken den zweiten Aspekt, indem sie die Schachtelung von Klassen unterstützen.
Vorteile:
- Mehr Flexibilität bzgl. Sichtbarkeit und Information Hiding
- Klassendeklaration dichter bei ihren Anwendungen - Erlaubt syntaktische Abkürzungen
Eine Klasse heißt in Java geschachtelt (engl.
nested), wenn sie innerhalb der Deklaration einer anderen Klasse deklariert ist:
- als Komponente (ähnlich einem Attribut),
- als lokale Klassen (ähnlich einer lokalen Variablen) - als anonyme Klassen bei der Objekterzeugung.
Ist eine Klasse nicht geschachtelt, nennen wir sie global (engl. top-level).
Java unterscheidet statische und innere Klassen.
Statische Klassen:
Geschachtelte Klassen heißen statisch, wenn sie mit dem Modifikator static deklariert sind.
Statische Klasse haben die gleiche Bedeutung wie globale Klassen. Allerdings ergeben sich andere Sichtbarkeits- und Zugriffsbereiche. Insbesondere:
- Geschachtelte Klassen können als privat deklariert werden, so dass sie außerhalb der umfassenden Klasse nicht verwendet werden können.
- Geschachtelte Klassen können auf private Attribute und Methoden der umfassenden Klasse zugreifen.
Beispiel: (statische Klassen)
public class SLinkedList2 {
private SEntry entries = null;
private int size = 0;
private static class SEntry { int head;
SEntry tail;
}
int getFirst() { ... } ...
}
Der Typ SEntry ist nur innerhalb von SLinkedList2 sichtbar und zugreifbar.
Bemerkung:
• Die Zugriffs- und Sichtbarkeitsregeln im
Zusammenhang mit geschachtelten Klassen sind recht komplex (siehe folgendes Beispiel).
• Zugreifbare geschachtelte Klassen können
über zusammengesetzte Namen außerhalb der umfassenden Klasse angesprochen werden ( z.B. SLinkedList2.SEntry ).
Beispiel: (mehrfach geschachtelte Klassen)
public class MyClassIsMyCastle { private static int streetno = 169;
private static class FirstFloor { private static class DiningRoom {
private static int size = 36;
private static void mymessage(){
System.out.print("Access to streetno");
System.out.println(": "+ streetno );
} } }
private static class SecondFloor { private static class BathRoom {
private static int size = 16;
private static void mymess(){
System.out.print("I can access the ");
System.out.print("dining room size: ");
System.out.println(
FirstFloor.DiningRoom.size );
} } }
public static void main( String[] argv ) { FirstFloor.DiningRoom.mymessage();
SecondFloor.BathRoom.mymess();
}
Innere Klassen:
Geschachtelte Klasse, die nicht statisch sind, heißen innere Klassen.
Sei K eine Klasse und INN eine direkte innere Klasse von K. Dann bekommt jedes INN-Objekt eine
Referenz auf das K-Objekt, in deren Kontext es erzeugt wurde.
Beispiel: (innere Klassen)
Wir betrachten einfach verkettete Listen:
- SLinkedListIter: Listen mit Iteratoren - SEntry: die Objekte für die Verkettung
- Iterator: die Iterator-Objekte als innere Objekte zu SLinkedListIter-Objekten
:SLinkedListIter ml:
size:
entries:
:SEntry head:
tail:
:SEntry head:
tail:
:SEntry head:
tail:
:Iterator this$0:
current:
iter:
8 2
4
3
•
import java.util.NoSuchElementException;
class SLinkedListIter { private int size = 0;
private SEntry entries = null;
private static class SEntry { ... } int getFirst(){ ... }
...
public class Iterator { private SEntry current;
Iterator() {
current = entries;
}
boolean hasNext() {
return current != null;
}
int next() {
if( current == null ) {
throw new NoSuchElementException();
}
int res = current.head;
current = current.tail;
return res;
} }
public Iterator createIterator() { return new Iterator();
}
class SLinkedListIterMain {
public static void main( String[] argf ){
SLinkedListIter ml = new SLinkedListIter();
ml.addFirst(8);
ml.addFirst(2);
ml.addFirst(4);
SLinkedListIter.Iterator iter
= ml.createIterator();
while( iter.hasNext() ) {
System.out.println( iter.next() );
} } }
Pakete:
Große Programme bestehen aus hunderten und
tausenden von Typen/Klassen, die von unterschiedlichen EntwicklerInnen und Institutionen realisiert und
verwaltet werden.
Es ist von großer Bedeutung, diese Klassen geeignet zu gruppieren und einzuteilen. Wichtige Aspekte:
- Auffinden, Verstehen des Zusammenhangs - Übersetzungs-, Installationsorganisation - Zugriffsrechte, Namensräume
- Pflege, Wartung
Für diese Aufgabenbereiche gibt es Modulkonzepte.
Javas Pakete bieten ein relativ einfache Lösung dafür:
- Ein Paket hat einen Namen P. Der Name besteht ggf. aus mehreren Teilen.
- Ein Paket P ist üblicherweise in einem Dateiver- zeichnis mit Namen P abgelegt.
Beispiel:
Paket java.lang ist abgelegt in .../java/lang - Ein Paket ist eine endl. Menge von Übersetzungs-
einheiten; der Paketname erscheint am Anfang der Übersetzungseinheiten.
- Pakete stellen einen Zugriffsbereich dar: Alle ohne Zugriffsmodifikator deklarierten Programm- elemente sind paketweit zugreifbar.
- Pakete bilden Namensräume: Ist P ein Paket, dann können alle Klassen K in P mittels P.K angesprochen werden (vollständiger Name).
- Es gibt keine Paket-Hierarchie/Unterpakete.
Beispiel: (Anwendung von Paketen)
Wir benutzen die Listenklasse LinkedList aus dem Paket java.util in unserem Paket kalau.
package kalau;
public class AufEinWort {
public static void main( String[] argf ){
java.util.LinkedList ml =
new java.util.LinkedList();
ml.addLast("Urin");
ml.addLast("stinkt");
java.util.Iterator iter = ml.iterator();
while( iter.hasNext() ) {
System.out.print( iter.next() );
}
System.out.println();
} }
package kalau;
import java.util.LinkedList;
import java.util.Iterator;
public class AufEinWort {
public static void main( String[] argf ){
LinkedList ml = new LinkedList();
ml.addLast("Urin");
ml.addLast("stinkt");
Iterator iter = ml.iterator();
...
}
Variante mit Import der angegebenen Typnamen:
Variante mit Import aller Typnamen des Pakets java.util:
package kalau;
import java.util.*;
public class AufEinWort { ...
}
