CS1005 Objektorientierte Programmierung

Bachelor of Science (Informatik)

Objektorientierung

Seite 1

Th Letschert

Meilensteine in der Softwareentwicklung

Meilensteine in der Softwareentwicklung

Von der Maschinensprache zur problemorientierten zur hheren Sprache
Programme werden mit menschlichen Ausdrucksweisen formuliert
LOADr1,x LOADr2,y ADDr1,r2x=2*(x+y) LOADr2,z MULTr2,$2 STOREr2,x

Seite 2

Meilensteine in der Softwareentwicklung

Meilensteine in der Softwareentwicklung

Modularisierungs-Techniken

Nach dem Vorbild der Ingenieurwissenschaften (speziell der Elektrotechnik) wird komplexe Software in Module aufgeteilt. Fortschritt in der Softwaretechnik: Antwort auf die Frage: Was ist ein Software-Modul?

Begriff Modul

Ursprnglich Maeinheit / Gre standardisierter Bauteile von Gebuden spter Bezeichnung dieser Bauteile selbst 1950er: Bezeichnung standardisierter Bauteile in der Elektronik
Vorbild Bautechnik

1970er: bernahme der Idee und des Begriffs standardisierter Bauteile in die Informatik
Vorbild: Elektrotechnik/Elektronik / Einsatz: Betriebssystementwicklung (sehr groe Programme)

2000er: bernahme der Idee und des Begriffs standardisierter Bauteile in die hhere Ausbildung

Seite 3

Modularisierung Erste Modularisierungs-Techniken Unterprogramm-Technik

Identischen Programmcode wiederverwenden Wiederverwendbarer Programmcode mit Parametern (Eingangswerten) Lokale Variablen, lokalem Algorithmus Ergebnis (Rckgabewert)

Funktionen / Prozeduren

Seite 4

Modularisierung und das Geheimnisprinzip Module bestehen klar erkennbar aus

Schnittstelle
Von auen zugreifbarer Teil der Funktionalitt zur Verfgung stellt

Implementierung
Interner Mechanismus der die Funktionalitt realisiert

D. Parnas Evangelist des Geheimnisprinzips

Geheimnisprinzip (Information Hiding Principle)

Der Schnittstellen-Anteil soll so gro wie ntig sein. Der Implementierungsanteil soll so gro wie mglich sein. Ein Modul soll mglichst viel zu seinem Geheimnis machen.

Schnittstelle ImplemenImplementierung tierung

Anwender: ist froh ber alles was er nicht wissen muss, wenn er das Bauteil verwenden will.
Seite 5

Entwickler: ist froh ber alles, auf das der Anwender nicht zugreifen kann: es kann ohne Rcksprache ersetzt werden.

Modularisierung und das Geheimnisprinzip Geheimnisprinzip: Schnittstelle (ffentlich) und Implementierung (privat)
sind bei allen Software-Komponenten stets explizit und klar erkennbar zu trennen !

Ziel und Zweck der Trennung:

Programmkonstrukte werden zu greren abstrakteren SW-Komponenten zusammengefasst, die einfacher zu benutzen, zu warten, auszutauschen sind.
Einfaches und auerordentlich erfolgreiches Prinzip der Software-Entwicklung Zunchst: Entwurfs- und Dokumentationsanleitung Heute: Moderne Programmiersprachen untersttzen das Geheimnisprinzip durch Sichtbarkeitsbeschrnkungen (Unterscheidung public / private ) und mit speziellen Konstrukten (wie z.B. Klassen)

Seite 6

Modularisierung und das Geheimnisprinzip Kopplung

von Anwendung und Entwicklung nur ber die Schnittstelle

Das Geheimnisprinzip
sorgt fr minimale Schnittstellen und so fr

maximale Entkopplung der Komponenten maximale Entkopplung der Komponente-Entwickler

ImplemenImplementierung tierung ImplemenImplementierung tierung ImplemenImplementierung tierung

ImplemenImplementierung tierung
Seite 7

Klasse als Modul

Seite 8

Th Letschert

Modularisierung mit Funktionen Funktionen: Schnittstelle und Implementierung

/* Schnittstelle * Sortiere eine Liste * Eingabe l: Liste vergleichbarer Daten * Ergebnis: Liste in sortierter Form, aufsteigende Reihenfolge */ void sort(List<Integer> l) { Collections.sort(l); }

Implementierung

Seite 9

Modularisierung mit Klassen: Modularer Entwurf Beispiel: Telefonbuch

public class TelefonBuchAnwendung { static String[] alleNamen = new String[100]; static int[] alleNr = new int[100]; static int letzterIndex = -1; static void eintrage(String name, int nr) { letzterIndex = letzterIndex+1; alleNamen[letzterIndex] = name; alleNr[letzterIndex] = nr; } static int suche(String name) { for (int i=0; i<=letzterIndex; i++) { if (name == alleNamen[i]) { return alleNr[i]; } } return -1; } public static void main(String args[]) { eintrage("Hugo", 4711); eintrage("Karla", 8150); System.out.println(suche("Hugo")); System.out.println(suche("Karla")); } }
Seite 10

Modularisierung mit Klassen: Modularer Entwurf Beispiel: Telefonbuch

public class TelefonBuchAnwendung { static String[] alleNamen = new String[100]; static int[] alleNr = new int[100]; static int letzterIndex = -1; static void eintrage(String name, int nr) { letzterIndex = letzterIndex+1; alleNamen[letzterIndex] = name; alleNr[letzterIndex] = nr; } static int suche(String name) { for (int i=0; i<=letzterIndex; i++) { if (name == alleNamen[i]) { return alleNr[i]; } } return -1; } public static void main(String args[]) { eintrage("Hugo", 4711); eintrage("Karla", 8150); System.out.println(suche("Hugo")); System.out.println(suche("Karla")); } }
Seite 11

Modul Telefonbuch

Nutzer des Telefonbuchs

Modularisierung mit Klassen: Modularer Entwurf Beispiel: Telefonbuch

class Telefonbuch { static String[] alleNamen = new String[100]; static int[] alleNr = new int[100]; static int letzterIndex = -1; static void eintrage(String name, int nr) { letzterIndex = letzterIndex+1; alleNamen[letzterIndex] = name; alleNr[letzterIndex] = nr; }

Modul Telefonbuch als Klasse implementiert

static int suche(String name) { for (int i=0; i<=letzterIndex; i++) { if (name == alleNamen[i]) { return alleNr[i]; } } return -1; } TelfonBuch.eintrage('Hugo', 4711) TelefonBuch.eintrage('Karla', 8150)

Nutzer des Telefonbuchs

println TelfonBuch.suche('Hugo') println TelfonBuch.suche('Karla')

Seite 12

Modularisierung mit Klassen: Modularer Entwurf Public und Private: Schnittstelle / Implementierung trennen
class Telefonbuch { private static String[] alleNamen = new String[100]; private static int[] alleNr = new int[100]; private static int letzterIndex = -1; public static void eintrage(String name, int nr) { letzterIndex = letzterIndex+1; alleNamen[letzterIndex] = name; alleNr[letzterIndex] = nr; } public static int suche(String name) { for (int i=0; i<=letzterIndex; i++) { if (name == alleNamen[i]) { return alleNr[i]; } } return -1; } }

Modul Telefonbuch als Klasse mit Schnittstelle / Implementierung klar getrennt Compiler berwacht die Trennung!

TelfonBuch.eintrage('Hugo', 4711) TelefonBuch.eintrage('Karla', 8150) println TelfonBuch.suche('Hugo') println TelfonBuch.suche('Karla') TelfonBuch.letzterIndex = 100;
Seite 13

Nutzer des Telefonbuchs

Klasse: Modularisierungskonstrukt Modularisierung mit Klassen

Klassen kapseln (d.h. machen zu einem Modul) die Organisation der Speicherung von Daten und Funktionen die auf diesen Daten operieren und von der Art der Speicherung abhngig sind. Die Kapselung fhrt zu einer besseren Organisation des Codes

Seite 14

Modularisierung mit Funktionen Beispiel: Vektorrechnung in der Ebene

Vektoren in der Ebene haben eine x- und eine y-Koordinate. Man kann sie addieren, subtrahieren und mit einem Skalar multiplizieren

Daten
Die Daten der Vektoren (x-, y-Koordinate) werden jeweils durch eine Liste dargestellt.
a = new int[]{3,4}; b = new int[]{2,3};

a = 3,4

b = 2,3

Operationen
Die Vektoren-Operationen werden als Funktionen realisiert.
public static int[] vektorAdd(int[] x, int[] y) { return new int[]{x[0] + y[0], x[1] + y[1]}; } public static int[] vektorSub(int[] x, int[] y) { return new int[]{x[0] - y[0], x[1] - y[1]}; } public static int[] vektorSkalarMult(int s, int[] x) { return new int[]{s * x[0], s * x[1]}; }
Seite 15

Modularisierung mit Funktionen Beispiel: Vektorrechnung in der Ebene

package vektor; public final class Vektor { private Vektor() { }

Schnittstelle

public static return } public static return } public static return } }

int[] vektorAdd(int[] x, int[] y) { new int[]{x[0] + y[0], x[1] + y[1]}; int[] vektorSub(int[] x, int[] y) { new int[]{x[0] - y[0], x[1] - y[1]}; int[] vektorSkalarMult(int s, int[] x) { new int[]{s * x[0], s * x[1]};

Implementierung

int[] a = {3, 4}; int[] b = {2, 3}; System.out.println(Arrays.toString(Vektor.vektorAdd(a, b))); System.out.println(Arrays.toString(Vektor.vektorSub(a, b))); System.out.println(Arrays.toString(Vektor.vektorSkalarMult(3, a)));
Seite 16

Modularisierung mit Funktionen Beispiel: Vektorrechnung in der Ebene / Modularisierungsproblem

Pfui !
package vektor; public final class Vektor { private Vektor() { }
sehr starke Kopplung: Der Anwender muss die Reprsentation der Vektoren kennen und beachten!

Schnittstelle

public static return } public static return } public static return } }

int[] vektorAdd(int[] x, int[] y) { new int[]{x[0] + y[0], x[1] + y[1]}; int[] vektorSub(int[] x, int[] y) { new int[]{x[0] - y[0], x[1] - y[1]}; int[] vektorSkalarMult(int s, int[] x) { new int[]{s * x[0], s * x[1]};

Implementierung

int[] a = {3, 4}; int[] b = {2, 3}; System.out.println(Arrays.toString(Vektor.vektorAdd(a, b))); System.out.println(Arrays.toString(Vektor.vektorSub(a, b))); System.out.println(Arrays.toString(Vektor.vektorSkalarMult(3, a)));
Seite 17

Modularisierung mit Klassen: Modularer Entwurf Problematik des modularen Ansatzes im Fall der Vektoren Mangelhafte Kapselung
Wissen ber die Implementierung (speziell die Art der Speicherung in Listen) ist verstreut auf Vektor-Code (Funktionen: VektorAdd, ) und Anwendungscode (Anlegen von Vektoren) Problem Kopplung: Beides kann nur gemeinsam gendert werden Die Anwendung bentigt zu viel Wissen ber die Implementierung Schnittstelle und Implementierung sind nicht klar getrennt Konsequenz aufwndige Wartung aufwndige Verwendung Fehleranflligkeit

Seite 18

Modularisierung mit Klassen: Modularer Entwurf Grenzen des modularen Ansatzes

Ein Ding (z.B. ein Telefonbuch) kann problemlos mit einem modularen Ansatz modelliert werden. Viele gleichartige Dinge (z.B. Vektoren) knnen nur schlecht mit einem modularen Ansatz modelliert werden.
Jedes einzelne Ding (z.B. jeder Vektor) bentigt seine eigene Reprsentation Diese Reprsentationen sind zwar gleichartig aber nicht gleich Ein Modul kann aber nur eine Reprsentation verwalten (kapseln)

Erforderlich ist ein Ansatz der Modularisierung, der Klassen und Individuen behandeln kann!

Seite 19

Objektorientierung: Klasse als Typ

Seite 20

Th Letschert

Modularisierung mit Klassen: Objektorientierter Entwurf Objektorientierung / technisch: Erweiterung des modularen Ansatzes
Klassen Klassen beinhalten das Gemeinsame von individuellen Exemplaren. Objekte Die Exemplare werden Objekte genannt.

Objektorientierung / philosophisch: Grundprinzip der Welt in SW

Klassen Reprsentieren Arten von Dingen Objekte Reprsentieren einzelne Exemplare ihrer jeweiligen Art Die Entsprechung Welt (Art / Exemplar) <~> Software (Klasse / Objekt) macht die Objektorientierung zur besten Modellierungstechnik, sie erlaubt es Dinge so zu modellieren, wie sie wirklich sind.

Seite 21

Modularisierung mit Klassen: Objektorientierter Entwurf Klassen und Objekte in Programmen

Klassen kapseln die Organisation der Speicherung von Daten und Funktionen die auf diesen Daten operieren und von der Art der Speicherung abhngig sind. Darber hinaus knnen die Funktionen logisch den Daten zugeordnet werden. Mann nennt sie dann Methoden. Daten mit den ihnen zugeordneten Methoden nennt man Objekte.
Mit der Objekt-Orientierung kommt zu der Kapselung eine philosophisch andere Sicht der Software. Auch hiermit werden keine wirklich neuen Fhigkeiten erreicht. Die Software-Entwicklung wird natrlicher und damit einfacher.

Seite 22

Modularisierung mit Klassen: Objektorientierter Entwurf Klassen und Objekte in Programmen

Klassen definieren die Art der Speicherung und die Operationen (Funktionen und Methoden) Objekte sind Exemplare (Instanzen) einer Klasse sie enthalten die jeweils unterschiedlichen Daten. Objekte haben i.A. einen sich ndernden Zustand. Methoden eines Objekts operieren auf den Daten des Objekts

Static
Das Schlsselwort static in einer Klassendefinition sagt, dass es sich um etwas Allgemeines Klassen-bezogenes handelt. Etwas das sich auf die Klasse insgesamt bezieht. Fehlt das Schlsselwort static dann handelt es sich um etwas Objekt-bezogenes, etwas das einzelnen Objekten zugeordnet ist.

Seite 23

Modularisierung mit Klassen: Objektorientierter Entwurf Beispiel : Vektor-Klasse

public class Vektor { private int[] rep; // Repraesentation: intern, geheim ! public Vektor(int x, int y) { // Konstruktor, erzeugt Repraesentation rep = new int[]{x, y}; } public static Vektor vektorAdd(Vektor x, Vektor y) { return new Vektor(x.rep[0] + y.rep[0], x.rep[1] + y.rep[1]); } public static Vektor vektorSub(Vektor x, Vektor y) { return new Vektor(x.rep[0] - y.rep[0], x.rep[1] - y.rep[1]); } public static Vektor vektorSkalarMult(int s, Vektor x) { return new Vektor(s * x.rep[0], s * x.rep[1]); } }

Vektorklasse: Alles in Einem zusammengefasst (gekapselt): - Interne Darstellung (Speicherung) der Individuen (Objekte) - Konstruktion - Funktionen Seite 24

Modularisierung mit Klassen: Objektorientierter Entwurf Beispiel : Vektor-Klasse / Nutzung

public class VektorNutzer { private VektorNutzer() { } public static void main(String[] args) { Vektor a = new Vektor(3, 4); Vektor b = new Vektor(2, 3); Vektor c = Vektor.vektorAdd(a, b); } }

Seite 25

Modularisierung mit Klassen: Objektorientierter Entwurf Beispiel: Modifikation der internen Speicherung
public class Vektor { private int x; private int y; public Vektor(int x, int y) { this.x = x; this.y = y; } public static Vektor vektorAdd(Vektor v1, Vektor v2) { return new Vektor(v1.x + v2.x, v1.y + v2.y); } etc }
public class VektorNutzer { public static void Vektor a Vektor b Vektor c } } Seite 26 main(String[] args) { = new Vektor(3, 4); = new Vektor(2, 3); = Vektor.vektorAdd(a, b);

Modifizierung der Reprsentation

Anwendungscode ist nicht betroffen

Modularisierung mit Klassen: Objektorientierter Entwurf

3 4 2 3

Werte: ewig, unvernderlich (mathematisch)

+
5 7

Vektoraddition, funktionale Sicht: aus zwei Vektoren konstruiere einen dritten

Objekte: vernderlich (real) 3 4 vorher

2 3 5 7 nachher

Vektoraddition, OO-Sicht: ein Vektor wird durch Addition vergrert.

Seite 27

Modularisierung mit Klassen: Objektorientierter Entwurf Objektorientierung: Methode

public class Vektor { private int x; private int y; public Vektor(int x, int y) { this.x = x; this.y = y; } public void add(Vektor v2) { this.x = this.x + v2.x; this.y = this.y + v2.y; } etc } Vektor a = new Vektor(3,4) Vektor b = new Vektor(2,3) a.add(b);

2 b 3
a

3 4 vorher

a.add(b)

5 a 7 nachher
this : dieser

Das eigene x und y werden verndert

Vektor (ich), der den Code gerade ausfhrt. this.x : das x von diesem Vektor (von mir)

Anwendungscode

Vektoraddition ist hier eine Vernderung eines Vektors mit Hilfe eines anderen (v2). Nicht eine Funktion, die aus zwei Vektoren einen neuen macht.
Seite 28

Modularisierung mit Klassen: Objektorientierter Entwurf Auch Daten knnen statisch (d.h. Klassen-bezogen) sein

class Vektor { int x = 0 int y = 0 Vektor(x, y) { this.x = x this.y = y } static Vektor nullVektor = new Vektor(0,0) }

Klasse Klassen-Komponente
Vektor v = Vektor.nullVektor;

statische Daten-Komponente: es gibt genau einen Null-Vektor

Seite 29

Modularisierung mit Klassen: Objektorientierter Entwurf

Klassen-Variable vs. Objekt-Variable Funktion vs. Methode

Objekt-Variable:
Variable die zu jedem Objekt einer Klasse gehrt nicht-statische Variable

public class C { private static int a; private int b; public void m(int c) { int d = 0; d = a+b+c+d; .... } public static void f(int c) { int d = 0; d = a+b+c+d; .... } }

Klassen-Variable:
Variable die zu einer Klasse insgesamt gehrt statische Variable

Methode:
Funktion die zu jedem Objekt einer Klasse gehrt auch: nicht-statische Methode

Funktion (statische Methode):

Funktion die zu einer Klasse gehrt Ausfhrung ohne Bezug zu einem Objekt
Seite 30

a: Klassenvariable b: Objektvariable c: Parameter d: lokale Variable m: Methode f: Funktion, statische Methode

Klasse als Typ: OO Philosophie

Klasse als Typ

Baer
Instanzierung (Objekt-Erzeugung) brumm

Klasse = Typ / Konstruktions-Muster fr Objekte Definition: ohne static vor der Definition von Methoden oder Variablen Aufruf einer Methode: Objekt-Name . Methoden-Name (..Parameter..)
(Aufruf Methode anderes Objekt) Methoden-Name (..Parameter..) (Aufruf Methode gleiches Objekt)

OO-Konzept: Programm = System interagierende Objekte

sagHallo! Baer bruno = new Baer(); bruno.sayHello();
Schleich Di' !
Nachricht = Methodenaufruf

OO Konzept: Objekte kommunizieren miteinander

Seite 31

Klasse als Typ: OO-Philosophie

Klasse = Typ der Objekte dieser Klasse

Baer
new
brumm brumm

kein static: Methode ist Bestandteil der Objekte

public final class Baer { public final class Baer { public void sagHallo() { public void sagHallo() { System.out.println("brumm"); System.out.println("brumm"); } } } }

bruno
brumm

probelmBaer

public final class Hallo { public static void main(String[] args) { Baer bruno = new Baer(); Baer problemBaer = bruno; Baer knut = new Baer(); bruno.sagHallo(); problemBaer.sagHallo(); knut.saghallo(); } }

knut
Eine Br-Klasse Zwei Br-Objekte Drei Br-Variablen

new - erzeugt ein Objekt als neues Exemplar (neue Instanz) der Klasse - und liefert einen Verweis auf das Objekt Die Zuweisung kopiert den Verweis
Seite 32

Modularisierung mit Klassen: Objektorientierter Entwurf

Klassen-Variable vs. Objekt-Variable Funktion vs. Methode

public class Baer { private static Person baerenFeind = stoiber; private boolean gutgelaunt = true; public static void setzeFeind( Person p) { baerenFeind = p; } public void sagHallo() { if ( gutgelaunt ) System.out.println(brum); else System.out.println(knurr); } public void begegne (Person p) { if ( p == baerenFeind ) gutgelaunt =false; }

baerenFeind: setzeFeind: gutgelaunt: sagHallo: begegne:

Klassen-Variable Klassen-Methode/Funktion Objekt-Variable Methode Methode

Baer flocke = new Baer(); Baer.setzeFeind(stoiber); flocke.sagHallo(); flocke.begegne(stoiber); flocke.sagHallo();

Aufruf einer Methode: objekt.Methode() Aufruf einer Funktion: Klasse.Methode()

Seite 33

Variablen und ihre Lebensdauer

public class Baer { public class Baer { private static String geBrumm1 = "BRUMM"; privatestatic staticString StringgeBrumm2 geBrumm1= ="GRRRR"; "BRUMM"; private private static String geBrumm2 = "GRRRR"; private boolean gutGelaunt; private boolean gutGelaunt; public void streicheln(){ public void streicheln(){ gutGelaunt = true; gutGelaunt = true; } } public void aergern(){ public void aergern(){ gutGelaunt = false; gutGelaunt = false; } } public void sagHallo(int n) { public void sagHallo(int n) { int i ; int i ; for ( i=0; i < n; i++ ) for i=0; i < n; i++ ) if ((gutGelaunt) if System.out.println( (gutGelaunt) geBrumm1); else System.out.println(geBrumm1); else System.out.println(geBrumm2); System.out.println(geBrumm2); } }

Alle Bren brummen auf 2 Arten

gebrumm1 und gebrumm2 gibt es jeweils genau einmal

Jeder Br hat seine eigene Laune: Pro Br gibt es eine Variable gutGelaunt Bren werden einzeln gestreichelt: Hat Auswirkung auf die Laune eines bestimmten Bren. Bei jedem Aufruf ein anderer Wert: Pro Methodenaufruf neu erzeugt Nur lokal fr den Algorithmus notwendig: Pro Methodenaufruf neu erzeugt

Seite 34

Stack und Heap

public class Hallo { public static void main(String[] args) { Baer bruno = new Baer(); bruno.aergern(); bruno.sagHallo(2); } }
false

gutGelaunt Methodenaufrufe
2

Brumm ein Objekt der Klasse Baer

GRRRR

sagHallo main

n bruno

i Heap geBrumm1 geBrumm2 Heap Klasse Baer

Stack
Seite 35

Situation zu Beginn der Ausfhrung von sagHallo

Initialisierung von Objekten

Konstruktor
initialisiert Objekte
wird bei Aufruf von new aktiviert wird benutzt um das neue Objekt mit Initial-Werten zu belegen

1-ter Konstruktor

public class C { private int b; public C() { b = 0; } public C(int b) { this.b = b; } }

2-ter Konstruktor

kann in Varianten existieren

werden (ohne static) in der Klasse der Objekte definiert

Wird wie Methoden definiert

Kein Ergebnistyp Name = Klassen-Name durch Art und Zahl der Parameter unterschieden

this.b : mein b, das b des aktuellen Objekts (das Objekt, das die Methode gerade ausfhrt)
Seite 36

Konstr.-Beispiel, Default-/Standard-Konstruktor
public class Baer { public class Baer { private static String geBrumm1 = "BRUMM"; private static String geBrumm1 = "BRUMM"; private static String geBrumm2 = "GRRRR"; private static String geBrumm2 = "GRRRR"; private boolean gutGelaunt; private boolean gutGelaunt; public Baer(){ public Baer(){ gutGelaunt = true; gutGelaunt = true; } } public Baer(boolean gutGelaunt){ public Baer(boolean gutGelaunt){ this.gutGelaunt = true; this.gutGelaunt = true; } } } } ..... .....
Der Konstruktor, der zu den Parametern passt, wird aufgerufen.
Konstruktor ohne Parameter : Default(Standard-) Konstruktor

Die Laune kann explizit gesetzt werden Der Standard-/DefaultBr ist gut gelaunt

Baer bruno Baer kurt Baer booboo

= new Baer(false); = new Baer(true); = new Baer();

Seite 37

Konstruktoren Konstruktoren werden nach der Initialisierung durch Zuweisung ausgefhrt. Klassen ohne jede Konstruktor-Definition haben automatisch einen (impliziten) Standard-Konstruktor (ohne Aktionen) Klassen mit mindestens einer expliziten Konstruktor-Definitionen haben keinem Standard-Konstruktor, wenn er nicht explizit definiert wird.
public class Baer { public class BaerString { private static geBrumm1 = "BRUMM"; private static String geBrumm1= ="GRRRR"; "BRUMM"; private static String geBrumm2 private static String geBrumm2 = "GRRRR"; private boolean gutGelaunt; private boolean gutGelaunt; } ... ... } public Baer(){ } } } public class Baer { public class BaerString { private static geBrumm1 = "BRUMM"; private static String geBrumm1= ="GRRRR"; "BRUMM"; private static String geBrumm2 private static String geBrumm2 = "GRRRR"; private boolean gutGelaunt; private boolean gutGelaunt; public Baer(boolean gutGelaunt){ publicthis.gutGelaunt Baer(boolean gutGelaunt){ = gutGelaunt; this.gutGelaunt = gutGelaunt; } } ... ...

Baer booboo = new Baer(); //OK

Baer booboo = new Baer(); //FEHLER

Seite 38

Objekt-Initialisierer Initialisierung von Objekt-Variablen: Objekt-Initialisierer

class C { public int x = -1; // Zuweisung public int y; // implizite Zuweisung von 0 { // Objekt-Initialisierer x=1; y=2; System.out.println(Objekt fertig initialisiert!) } ...... } Objekt-Initialisierer: Anweisungsfolge in der Klassendefinition wird bei jeder Objekterzeugung ausgefhrt

Seite 39

Klassen-Initialisierer

Initialisierung von Klassenvariablen durch Zuweisung

class C { private static int x = 5; .... }

Initialisierung von Klassenvariablen durch Klassen-Initialisierer

class C { private static int x; ...
Objekt-Initialisier: ohne static Klassen-Initialisierer: mit static

static { // Klasseninitialisierer x = 12; ... System.out.println(''Klasse fertig initialisiert''); } .....

} Klassen-Initialisierer: Anweisungsfolge in der Klassendefinition wird einmal bei der Initialisierung der Klasse ausgefhrt
Seite 40

Initialisierungsreihenfolge

Reihenfolge der Initialisierungen

1. Klassenvariablen
1. implizite Zuweisung 2. explizite Zuweisung 3. statischer Initialisierer 4. Zuweisungen in einem Konstruktor

2. Objektvariablen
1. implizite Zuweisung 2. explizite Zuweisung 3. Objekt-Initialisierer 4. Zuweisungen in einem Konstruktor

Seite 41