Seite 1

Java: Objektorientierte Programmierung

Richard Göbel

Seite 2

Grundlagen der OO-Programmierung- Ansatz und Begriffe

Natürliche Abbildung von Objekten der realen Welt auf ein Modell mit entsprechenden Datenstrukturen:

Zusammenfassen von Objekten eines Typs zu Klassen

Definition eines einheitlichen Schemas zur Beschreibung von Objekten einer Klasse:

Merkmale: Attribute

Operationen: Methoden

Festlegen einer Klassenhierarchie mit Unter- und Oberklassen.

Lösung der Aufgabenstellung durch Entwicklung geeigneter Methoden.

Seite 3

Grundlagen der OO-Programmierung- Beispiel: Hochschule Teil I

ProgrammierenBetriebssysteme

Datenbanksysteme

Müller Meier

Huber Becker

Schmidt

Rote

Gelbor Unblau

Dozenten

StudentenVorlesung

Personen

Seite 4

Grundlagen der OO-Programmierung- Beispiel: Hochschule Teil II

StudentString name;int alter;Vorlesung[] teilnahme;

DozentString name;int alter;Vorlesung[] angebot;

PersonString name;int alter;

VorlesungString bezeichnung;int stunden;

Seite 5

Grundlagen der OO-Programmierung- Beispiel: Hochschule Teil III

class Person { String name; int alter;

String getName() { return name;}

void setName(String na) {

name = na;}

int getAlter() { return alter;}

void setAlter(int al) { alter = al;}}

class Student extends Person{ Vorlesung[] teilnahme;

Vorlesung[] getTeilnahme() { return teilnahme; }

void setTeilnahme (Vorlesung[] t) { teilnahme = t; }}

Seite 6

Grundlagen der OO-Programmierung- Erzeugen von Objekten einer Klasse

class Test{ public static void main (String[] args) { Person p; p = new Person(); p.setName(“Meier“); p.setAlter(19);

System.out.println(p.getName()); System.out.println(p.getAlter()); }}

Operator zur Erzeugung eines Objekts

Konstruktor

Methodenaufruf

Seite 7

Grundlagen der OO-Programmierung- Definition eigener Konstruktoren

class Vorlesung{ String bezeichnung; int stunden;

Vorlesung (String bez) { bezeichnung = bez; } . . .}

Seite 8

Grundlagen der OO-Programmierung- Verwendung von Konstruktoren

. . .Student s;s = new Student();s.setName(“Meier“);s.setAlter(19);

Vorlesung[] v;v = new Vorlesung[2];v[0] = new Vorlesung(“Datenbanksysteme“);v[1] = new Vorlesung(“Betriebssysteme“);s.setTeilnahme(v); . . .

Seite 9

Übung

Seite 10

Grundlagen der OO-Programmierung- Statische Elemente: Konzept

Statische Variable und Funktionen: sind direkt einer Klasse zugeordnet.

können direkt über den Klassennamen angesprochen werden, ohne dass ein Objekt der Klasse verwendet werden muss.

Der Wert einer statischen Variable ist identisch für alle Objekte der Klasse.

Für statische Variablen und Funktionen spielt die Klasse ausschließlich die Rolle eines „Behälters“!

Seite 11

Grundlagen der OO-Programmierung- Statische Variablen: Deklaration

class Person { static int numGen = 1; int nummer; String name;

Person () { nummer = numGen++;}

Person (String na) { nummer = numGen++; name = na;} . . .}

Seite 12

Grundlagen der OO-Programmierung- Statische Variablen: Anwendung

class Test{ public static void main (String[] args) { Person p1 = new Person(“Meier“), p2 = new Person(“Becker“); System.out.println(p1.nummer); System.out.println(p2.nummer); }}

statische Hauptfunktio

n

Attributzugriff

Seite 13

Grundlagen der OO-Programmierung- Statische Variablen: Initialisierung

class Person{ static int numGen; int nummer; String name; . . . static { numGen = 1; } . . .}

StaticInitializer

Seite 14

Grundlagen der OO-Programmierung- Statische Funktionen: Deklaration

class Person{ static int numGen = 1;

static void setGenWert (int wert) { numGen = wert; }

static int getGenWert () { return numGen; } . . .}

Seite 15

Grundlagen der OO-Programmierung- Statische Funktionen: Anwendung

class Test{ public static void main (String[] args) { Person.setGenWert(10); Person p1 = new Person(“Meier“), p2 = new Person(“Becker“); System.out.println(p1.getGenWert()); System.out.println(Person.getGenWert()); }}

Seite 16

Grundlagen der OO-Programmierung- Überladen von Funktionssymbolen

In praktisch allen objektorientierten Sprachen lassen sich verschiedene Funktionen und Methoden mit identischem Namen definieren.

Funktionen oder Methoden mit identischem Namen unterscheiden sich mindestens bezüglich einer der folgenden Kriterien:

Zughörigkeit zu einer Klasse

Anzahl der Argumente

Typ der Argumente

Begriff für dieses Konzept: Overloading

Seite 17

Grundlagen der OO-Programmierung- Überladen von Methoden

class Person { String name;

String name() { return name; }

void name(String na) { name = na; }

. . .}

. . .Person p;p = new Person(“Meier“);System.out.println(p.name);p.name(“Becker“);System.out.println(p.name()); . . .

Seite 18

Grundlagen der OO-Programmierung- Überladen von Konstruktoren I

class Vorlesung { String bezeichnung = ““; int stunden = 0;

Vorlesung (String bez) { bezeichnung = bez; stunden = 4;}

Vorlesung (String bez, int std) { bezeichnung = bez; stunden = std;}

. . . }

Seite 19

Grundlagen der OO-Programmierung- Überladen von Konstruktoren II

class Vorlesung{ String bezeichnung; int stunden;

Vorlesung (String bez) { this(bez,4);}

Vorlesung (String bez, int std) { bezeichnung = bez; stunden = std;} . . .}

Der Aufruf eines anderen Konstruktors ist mit dem Schlüsselwort this möglich.

Damit ist die Wiederverwendung des Programmcodes aus dem anderen Konstruktor möglich!

Seite 20

Grundlagen der OO-Programmierung- Konstruktoren und Vererbung

Konstruktoren werden nicht vererbt!

Konstruktoren der Oberklasse lassen sich mit dem Schlüsselwort super aufrufen.

Enthält ein Konstruktor der Unterklasse keinen Aufruf eines Konstruktors der Oberklasse, dann:

erfolgt automatisch ein Aufruf eines passenden Konstruktors der Oberklasse

vor der Bearbeitung der Anweisungen des aktuellen Konstruktors

Wird kein eigener Konstruktor definiert, dann erzeugt Java automatisch einen Konstruktor ohne Argumente.

Seite 21

Grundlagen der OO-Programmierung- Überladen von Methoden der Oberklasse I

class Person { int alter;

void alter(int al) { alter = al; }

. . .}

class Student extends Person{ . . . void alter(int al) { if (al > 17) { alter = al; } } . . .}

Seite 22

Grundlagen der OO-Programmierung- Überladen von Methoden der Oberklasse II

class Student extends Person{ . . . void alter(int al)

{ if (al > 17) { super.alter(al); } } . . .}

Zugriff auf Funktionen der Oberklasse mit dem Schlüsselwort super

Vorteil: kein direkter Zugriff auf Attribute der Oberklasse in der Unterklasse.

Seite 23

Grundlagen der OO-Programmierung- Ansatz: Programmcode ohne Redundanz

Programmcode so organisieren, dass identischer Code an anderen Stellen mitbenutzt wird:

Verwendung anderer Funktionen, Methoden und Konstruktoren zur Realisierung eigener Funktionen.

Verwendung vorhandener Klassen durch Definition der eigenen Klasse als Unterklasse.

Vorteile: Programm wird kleiner und weniger komplex

Änderungen müssen an weniger Stellen durchgeführt werden

Seite 24

Grundlagen der OO-Programmierung- Weitere Möglichkeiten in Java

Deklarationen mit dem Schlüsselwort abstract: Für eine mit ‘abstract‘ deklarierte Klasse können keine Objekte erzeugt werden.

Eine mit ‘abstract‘ deklarierte Klasse kann Deklarationen von Funktionen ohne Rumpf enthalten, die in allen Unterklassen entsprechend der Deklaration definiert werden müssen.

Deklarationen mit dem Schlüsselwort final: Der Wert einer mit ‘final‘ deklarierter Variablen oder eines Attributs kann nicht

mehr geändert werden.

Eine mit ‘final‘ deklarierte Methode oder Funktion darf in einer Unterklasse nicht ersetzt werden.

Seite 25

Grundlagen der OO-Programmierung- Beispiel für eine ‚abstrakte‘ Klasse

abstract class Person{ . . . abstract void setID(String id);

abstract String getID(); . . .}

Seite 26

Grundlagen der OO-Programmierung- Beispiel für die Deklaration von Konstanten

class Student extends Person{ int Studiengang; final static int VWL = 1; final static int BWL = 2; final static int PHYSIK = 3;

Student(int sg) { Studiengang = sg; } . . .}

. . .Student s;s = new Student(Student.BWL);. . .

Seite 27

Übung