17.04.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II...

17.04.2000

Universität Dortmund, Lehrstuhl Informatik 1dittrich@cs.uni-dortmund.de

EINI IIEinführung in die Informatik

für Naturwissenschaftler und Ingenieure II

Prof. Dr. Gisbert Dittrich

Prof. Dr. G. Dittrich17.04.2000

EINI II Kap. 15: Einführung in die Vererbung

Gliederung

• Ziele von Klassen (Wiederholung)

• Phänomene bei der elementaren Vererbung• Syntax• Überschreiben von Methoden

• Auflösung von Zirkularität

• Einführendes Beispiel: • string_Klasse, Woerter_Gross

• Beispiel: • Person, Mann, Frau

Ziele von Klassen

• Schon besprochen:• Kapselung von Attributen+Methoden (wie struct)• Erweiterte Möglichkeiten gegenüber struct

– Überladen von Funktionen– Konstruktoren– Destruktoren

• Neu:• Effiziente Wiederverwendbarkeit

– dazu:---> Vererbung

Neudefinition der Klasse?

• Bisherige Mittel zum Modellieren von „ähnlichen“ Klassen: • Neudefinition der Klasse

– z.B.: Code kann kopiert werden.

• Das ist nicht so gut:• langweilig,• fehleranfällig,• nicht änderungsfreundlich.

Alternative: Vererbung

Seien A und B Klassen.

• A ist Oberklasse von B (B ist Unterklasse von A)• --> B „erbt“ Attribute und Methoden von A,

d.h. B „kennt“ Attribute und Methoden von A.

(Wie genau, wird im folgenden detailliert angegeben.)

• B fügt neue Attribute und Methoden zu denen von A hinzu, ggf. werden (alte) Methoden neu definiert.

• Jede Instanz von B ist auch Instanz von A.

Beispiel: String - Nur Großbuchstaben

• Definiere String als Klasse:• string_Klasse:

– Attribute: Zeichenkette, Länge– Methoden: Konstruktor, Destruktor, Lies, Schreibe

• Betrachte „Unterklasse“ • Woerter_Gross:

Für Zeichenketten, die Buchstaben nur als Großbuchstaben aufweisen.

string_Klasse 1. Versuch

class string_Klasse {private:

char * s; int laenge;

public:string_Klasse(char *);~string_Klasse();bool lies(char *);void schreib();char * dieKette();int DieLaenge();

};Nicht gut: siehe später !

public besagtan dieser Stelle: Übernahme der Zugriffspezifikationenvon string_Klasse in die neue Klasse.

die Klasse Woerter_gross erbt von der Klasse string_Klasse:Attribute und Methoden von String_Klasse sind in Woerter_Gross verfügbar.

Grundansatz Vererbung

class Woerter_Gross:public string_Klasse

Grundansatz Vererbung

class Woerter_Gross:public string_Klasse {public:

Woerter_Gross(char *);void schreib();

Verfeinerung des Grundansatzes

• 2 Arten des Verbergens:• Geheimnis (auch) vor den Kindern:

– A möchte Eigenschaften für sich behalten und nicht beim Vererben weitergeben:

– --> Wahl der Zugriffsspezifikation private• Familiengeheimnisse:

– Attribute und Methoden werden nur Erben bekannt gemacht, nicht aber Außenstehenden:

– --> Wahl der Zugriffsspezifikation protected

„Modifikation“ von string_Klasse

class string_Klasse {protected:

steht also für dieErben (und nur

für sie) zur Verfügung

Zusammenfassung

• Alle als public oder protected zugreifbaren Komponenten sind für die Erben sichtbar. • Die als private charakterisierten Komponenten sind in ihrer Sichtbarkeit auf die Klasse selbst beschränkt.

privateZugriff nur innerhalb

der Klasse

protectedZugriff nur innerhalb

der Klasseund ihrer Erben

publicKomponente ist

öffentlichzugänglich

Zugriffsspezifikation

Klassifikationshierarchie

Neuer Konstruktor: Heißt ja

wie die Klasse

class Woerter_Gross : publicpublic string_Klasse {public:

Woerter_Gross(char *);void schreib();

public besagt hier: Die Zugriffs-spezifikationen für die Komponenten bleiben beim Erben erhalten

Konstruktor für Woerter

Woerter_Gross::Woerter_Gross(char * t) : string_Klasse(t) {

for (int i=0; i < laenge ; i++)if (islower(s[i]))

s[i] = toupper(s[i]);}

Zugriff auf den Konstruktor der

Oberklasse string

Zugriff auf das Attribut laengeder Oberklasse

Anmerkung

• Effekt des Konstruktors (im Beispiel): • Es wird ein Objekt vom Typ Woerter_Gross geschaffen; die Buchstaben der initialisierenden Zeichenkette sind Großbuchstaben.• Der erste Schritt bei der Erzeugung des Objekts besteht im Aufruf des Konstruktors für die Vaterklasse (Syntax!).

Redefinition einer Methode

Die Methode schreib wird neu definiert (redefiniert, überschrieben); dabei wird die Methode der Vaterklasse verwendet.

void Woerter_Gross::schreib(){cout << “Ueberschriebene Methode "

<< "(Achtung)\t\t";string_Klasse::schreib();}

/* Woerter_Gross,* Vorlage EED, EINI II, * SS 99, überarbeitet GD 8.4.2000* demonstriert Vererbung (einfach)*/

#include <iostream.h>

// verwendete Funktionsprototypen:void strcpy(char * nach, char * von);int strlen(char * r);bool islower(char c);char toupper(char c);

/* Woerter_Gross, Fortsetzung 1 */

class string_Klasse {protected:

string_Klasse::string_Klasse (char *t) {int lgth = strlen(t);s = new char[lgth+1];strcpy(s, t);laenge = --lgth;// sonst letztes Zeichen '\0'// mitgezählt}

string_Klasse::~string_Klasse() {laenge = -1;delete &s;}

bool string_Klasse::lies(char * r) {int strlen(char *);if (strlen(r) <= laenge+1) {

laenge = strlen(r);strcpy(s, r);return true; }

elsereturn false;

void string_Klasse::schreib() {cout << s << endl;}

char * string_Klasse::dieKette() {return s;}

int string_Klasse::DieLaenge() {return laenge;}

class Woerter_Gross:public string_Klasse {

public:Woerter_Gross(char *);void schreib();

Woerter_Gross::Woerter_Gross(char * t):

string_Klasse(t) {for (int i=0; i < laenge ; i++)

if (islower(s[i])) s[i] = toupper(s[i]);

void Woerter_Gross::schreib(){cout << "Ueberschriebene Methode "

<< "(Achtung)\t\t";string_Klasse::schreib();}

int main() {string_Klasse *s =

new string_Klasse ("aBra");s->schreib();s->~string_Klasse();Woerter_Gross * grS =

new Woerter_Gross("abra");grS->schreib();cout << "Laenge: "

<<grS->DieLaenge();return 0;

} Woerter_Gross

void strcpy(char * nach, char * von) {while (*nach++ = *von++);

int strlen(char * r) {int f = 0;while (r[f++]);return f;}

bool islower(char c) {if (('a' <= c) && (c <= 'z'))

return true;else

return false;}

char toupper(char c) {if (islower(c))

return (c - 'a' + 'A');else

return c;}

Woerter_Gross Ausgabe

Ueberschriebene Methode (Achtung) ABRA

Laenge: 4

Zusammenfassung

• Klasse Woerter_Gross ist Spezialfall der Klasse string_Klasse • (Wörter enthalten nur Großbuchstaben).

• Erbende Klasse kann auf alle nicht als private gekennzeichneten Komponenten zugreifen.• Die Zugriffsspezifikation protected wurde eingeführt, um den Zugriff angemessen zu regeln

Zusammenfassung

• Ein neuer Konstruktor mußtemußte definiert werden (anderer Name):• Der Konstruktor der Oberklasse kann verwendet werden.

• Eine Methode wurde redefiniert • Hierbei wurde auch die gleichnamige Methode des Vaters verwendet.

• Die Syntax hierfür wurde eingeführt.

FrauFrau MannMann

PersonPerson

Beispiel: Männer und Frauen

Gemeinsame Eigenschaften: • Name (Beschränkung auf Vornamen), • Vater, • Mutter. • --> Oberklasse: Person

– Obige Eigenschaften dort formulieren

class Person {private:

string * Vorname;Frau * Mutter;Mann * Vater;

public:Person(char *);Person(string *);~Person();string * DerVorname();void SetzeMutter(Frau *);void SetzeVater(Mann *);void Druck(char *);

gemeinsame Eigenschaften

gemein-same

Methoden

Anmerkung

• Gemeinsame Eigenschaften private• --> von außen nicht zugreifbar. • Auch von Erben nicht:

– sonst als protected vereinbart.

Modellierung der Klasse Frau

• Konstruktor (aus Namen und aus Person),• hat Ehemann, • heiratet,• ist Ehefrau von.

class Frau: public Person {private:

Mann * Ehemann;public:

Frau(char *);Frau(Person *);void NimmZumManne(Mann *);Mann * EhefrauVon();

Analog: Modellierung Klasse Mann

• Konstruktor (aus Namen und aus Person),• hat Ehefrau, • heiratet,• ist Ehemann von.

class Mann: public Person {private:

Frau * Ehefrau;public:

Mann(char *);Mann (Person *);void NimmZurFrau(Frau *);Frau * EhemannVon();

Problem: Zirkularität

Person • erfordert die Kenntnis von Frau, Mann,

Mann • erfordert die Kenntnis von Person, Frau,

Frau • erfordert die Kenntnis von Person, Mann.

(Erinnert an forward in Pascal.)

Lösung

Deklaration sieht im Programm so aus:

class Mann;class Frau;class Person { ... }; class Frau: public Person { ... };class Mann: public Person { ... };

Dann erst folgen die Definitionen der Methoden.

hier werdendie Namen

bekanntgemacht

Konstruktoren für Klasse Person

Konstruktoren für die Klasse sind überladen, einmal Zeichenkette, dann string als Parameter.

Person::Person(char * v) {Vorname = new string(v);Vater = NULL;Mutter = NULL;}

Person::Person(string * s) {Vorname = s;Vater = NULL;Mutter = NULL;}

Weitere Methoden

Destruktor: • Ruft nur den Destruktor für die Zeichenkette auf

Person::~Person() {Vorname->~string();}

Die anderen Methoden (bis evtl. auf Druck) sollten klar sein. Die Methode Druck druckt den Vornamen aus und ruft ggf. die Druck-Methode für Vater und für Mutter auf.

void Person::Druck(char * s) {cout << s

<< "(Vorname) " << Vorname->dieKette() << endl;

if(Mutter != NULL) {cout << "\nDaten der Mutter:\n";Mutter->Druck("");}

if(Vater != NULL) {cout << "\nDaten des Vaters:\n ";Vater->Druck("");}

Bemerkenswert

• Aufrufe • Vater->Druck() und Mutter->Druck()benutzen die Tatsache, daß Vater und Mutter auch vom Typ Person sind.• In den Klassen Mann oder Frau sind keine neuen Methoden Druck vereinbart!

• Dies deutet an: • Vererbung erlaubt flexible Modellierung und Programmierung.

Konstruktoren und Methoden für die Klasse Mann

Mann::Mann(char * v) :Person(v) {Ehefrau = NULL;}

Mann::Mann(Person *p) : Person(p->DerVorname()){

Ehefrau = NULL;}

void Mann::NimmtZurFrau(Frau * thisLady) {Ehefrau = thisLady;}

Frau * Mann::EhemannVon(){return Ehefrau;}

Heiratsroutine

void Verheirate(Mann * m, Frau * f){m->NimmZurFrau(f);f->NimmZumManne(m);}

Bemerkenswert: steht außerhalb der Klassendefinitionen.

int main() {Mann * Adam = new Mann("Adam");Frau * Eva = new Frau("Eva");Mann * Kain = new Mann("Kain");Kain->SetzeMutter(Eva); Kain->SetzeVater(Adam);Mann * Abel = new Mann("Abel");Abel->SetzeMutter(Eva); Abel->SetzeVater(Adam);Adam->Druck("Zu Adam: ");

Eva->Druck("\nZu Eva:");Kain->Druck("\n\nAngaben zu Kain:");Abel->Druck("\n\nAngaben zu Abel:");Verheirate(Adam, Eva);cout << "\nverheiratet?\n";Eva->EhefrauVon()->

Druck("\tEva ist verheiratet mit:\n");Adam->EhemannVon()->

Druck("\tAdam ist verheiratet mit :\n ");return 0;}

Mann-Frau

Mann-Frau: AusgabeZu Adam: (Vorname) Adam

Zu Eva: (Vorname) Eva

Angaben zu Kain: (Vorname) Kain

Daten der Mutter: (Vorname) Eva

Daten des Vaters: (Vorname) Adam

Angaben zu Abel: (Vorname) Abel

Daten der Mutter: (Vorname) Eva

Daten des Vaters: (Vorname) Adam

verheiratet?

Eva ist verheiratet mit:

(Vorname) Adam

Adam ist verheiratet mit:

(Vorname) Eva (umformatiert: GD)

// Personen mit Unterklassen// Vorlage EED EINI II, SS 99, prog-27a; // Überarbeitet: GD 14.4.00// demonstriert Vererbung//

#include <iostream.h>#include <stdio.h>#include "clstring.h"

class Mann;class Frau;void Verheirate(Mann *, Frau *);

// Personen mit Unterklassen, Fortsetzung 1

class Person {private:

stringcl * Vorname;Frau * Mutter;Mann * Vater;

public:Person(char *);Person(stringcl *);~Person();stringcl * DerVorname();void SetzeMutter(Frau *);void SetzeVater(Mann *);void Druck(char *);

class Frau: public Person {private:

Mann * Ehemann; public:

Frau(char *);Frau (Person *);void NimmZumManne(Mann *);Mann * EhefrauVon();};

class Mann: public Person {private:

Frau * Ehefrau; public:

Mann(char *);Mann (Person *);void NimmZurFrau(Frau *);Frau * EhemannVon();};

Person::Person(char * v) {Vorname = new stringcl(v);Vater = NULL; Mutter = NULL;}

Person::Person(stringcl * s) {Vorname = s;Vater = NULL; Mutter = NULL;}

Person::~Person() {Vorname->~stringcl();}

stringcl * Person::DerVorname() {return Vorname;}

void Person::SetzeMutter(Frau * Mom) {Mutter = Mom;}

void Person::SetzeVater(Mann * Dad) {Vater = Dad;}

void Person::Druck(char * s) {cout << s << "\t(Vorname) " << Vorname->dieKette() << endl;if(Mutter != NULL) { cout << "\nDaten der Mutter: " << endl;

Mutter->Druck("");}if(Vater != NULL) { cout << "\nDaten des Vaters: " << endl;

Vater->Druck("");}};

Frau::Frau(char * v) :Person(v) {Ehemann = NULL;}

Frau::Frau(Person *p) :Person(p->DerVorname()){Ehemann = NULL;}

void Frau::NimmZumManne(Mann * erDa) {Ehemann = erDa;}

Mann * Frau::EhefrauVon(){return Ehemann;}

Mann::Mann(char * v) :Person(v) {Ehefrau = NULL;}

Mann::Mann(Person *p) :Person(p->DerVorname()){Ehefrau = NULL;}

void Mann::NimmZurFrau(Frau * thisLady) {Ehefrau = thisLady;}

Frau * Mann::EhemannVon(){return Ehefrau;}

void Verheirate(Mann * m, Frau * f){m->NimmZurFrau(f);f->NimmZumManne(m);}

int main() {Mann * Adam = new Mann("Adam");Frau * Eva = new Frau("Eva");Mann * Kain = new Mann("Kain");Kain->SetzeMutter(Eva);Kain->SetzeVater(Adam);

// Personen mit Unterklassen, Fortsetzung 7//int main() {Fortsetzung !!!!

Mann * Abel = new Mann("Abel");Abel->SetzeMutter(Eva);Abel->SetzeVater(Adam);Adam->Druck("Zu Adam: ");Eva->Druck("\nZu Eva:");Kain->Druck("\n\nAngaben zu Kain:");Abel->Druck("\n\nAngaben zu Abel:");Verheirate(Adam, Eva);cout << "\nverheiratet?\n";Eva->EhefrauVon()->Druck("\tEva ist

verheiratet mit: \n");Adam->EhemannVon()->Druck("\tAdam ist

verheiratet mit: \n");return 0;}

// Hilfsklasse stringcl in Datei "clstring.h"// Vorlage EED EINI II SS99, // überarbeitet GD 9.4.00

void strcpy(char * nach, char * von);int strlen(char * r);bool islower(char c);char toupper(char c);

void strcpy(char * nach, char * von) {while (*nach++ = *von++);}

int strlen(char * r) {int f = 0;while (r[f++]);return f;}

// Hilfsklasse stringcl, Fortsetzung 1

bool islower(char c) {if (('a' <= c) && (c <= 'z'))

return true;else

return false;}

char toupper(char c) {if (islower(c))

return (c - 'a' + 'A');else

return c;}

class stringcl {protected:

public:stringcl(char *);~stringcl();bool lies(char *);void schreib();char * dieKette();int DieLaenge();

stringcl::stringcl (char *t) {int lgth = strlen(t);s = new char[lgth+1];strcpy(s, t);laenge = --lgth;}

stringcl::~stringcl() {laenge = -1; delete &s;}

bool stringcl::lies(char * r) {int strlen(char *);if (strlen(r) <= laenge) {

laenge = strlen(r);strcpy(s, r);return true;}

else return false;}

void stringcl::schreib() {cout << s << endl;}

char * stringcl::dieKette() {return s;}

int stringcl::DieLaenge() {return laenge;}

17.04.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II...

Documents

Information Retrieval in XML- Dokumenten Norbert Fuhr Universität Dortmund fuhr@cs.uni-dortmund.de

Petri Netze II Vorlesung 2 SWS WS 99/00 Gisbert Dittrich FBI UniDo dittrich@cs.uni-dortmund.de

22.05.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II Einführung in die Informatik für Naturwissenschaftler und Ingenieure

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 12 Claudio Moraga, Gisbert Dittrich FBI Unido moraga@cs.uni-dortmund.de

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 9 Claudio Moraga; Gisbert Dittrich FBI Unido moraga@cs.uni-dortmund.de

Informatik Was ist Informatik? Was tun Informatiker? Informatikstudium Warum Informatik studieren? Bernd Schürmann schuermann@cs.uni-kl.de FB Informatik,

10.04.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II Einführung in die Informatik für Naturwissenschaftler und Ingenieure

Theoretische Informatik II - cs.uni-potsdam.de · Theoretische Informatik II §5.3: 1 NP-vollstandige Probleme¨ Methodik f¨ur Nachweis von NP-Vollst¨andigkeit Direkter Beweis ist

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 2 Gisbert Dittrich; Claudio Moraga FBI Unido moraga@cs.uni-dortmund.de

29.05.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II Einführung in die Informatik für Naturwissenschaftler und Ingenieure

Objekt-Komposition versus Vererbung: Decorator-Design-Pattern€¦ · O.Univ.-Prof. Dipl.-Ing. Dr. Wolfgang Pree Fachbereich Informatik cs.uni-salzburg.at Objekt-Komposition versus

Datenanalyse und Musik Katharina Morik Lehrstuhl Informatik VIII Universität Dortmund morik@ls8.cs.uni-dortmund.e

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 7 Claudio Moraga, Gisbert Dittrich FBI Unido moraga@cs.uni-dortmund.de

HyREX: Eine Hypermedia- Retrievalengine für XML- Dokumente Norbert Fuhr Universität Dortmund fuhr@cs.uni-dortmund.de

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 10 Claudio Moraga; Gisbert Dittrich FBI Unido moraga@cs.uni-dortmund.de

Reinforcement Learning 2 - cs.uni-potsdam.de · Universität Potsdam Institut für Informatik Lehrstuhl Maschinelles Lernen Reinforcement Learning 2 Uwe Dick

01.07.2000 Universität Dortmund, Lehrstuhl Informatik 1 dittrich@cs.uni-dortmund.de EINI II Einführung in die Informatik für Naturwissenschaftler und Ingenieure

slides-2.1-anim - cs.uni-potsdam.de€¦ · Einheit 2 Endliche Automaten . ENDLICHE AUTOMATEN æn von Computern Sichtwei,f THEORETISCHE INFORMATIK gabe Black Box chtung von außen

Desktop Video SPV 2 SWS SS 2000 Gisbert Dittrich FBI Unido dittrich@cs.uni-dortmund.de

EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 4 Claudio Moraga; Gisbert Dittrich FBI Unido moraga@cs.uni-dortmund.de