Vererbung Prolog Aufbaukurs SS 2000 Heinrich-Heine-Universität Düsseldorf Christof Rumpf.
Vererbung
description
Transcript of Vererbung
Vererbung
Das Prinzip der Vererbung im täglichen
Leben:
Walter besitzt ein Haus.
Walter erbt nun 10000Euro. Also besitzt er insgesamt:
10000
+
In C++:
Erblasser Erbe
--->Basisklasse
--->
abgeleitete Klasse
In C++ darf man einenErben (abgeleitete Klasse)
selbst basteln
Statt Basisklasse sagt man auch:Oberklasse, Vaterklasse
Statt abgeleiteter Klasse sagt man auch:Unterklasse, Sohnklasse, Subklasse
Eine abgeleitete Klasse wird in C++ wie folgt angegeben:
class Ei:public Huhn{
...}
Basisklasse abgeleitete Klasse
wird getrennt durch
Doppelpunkt
Zugriffsart
Die abgeleitete Klasse (kurz: Ableitung) besitzt
automatisch alle Member (Ausnahme: Konstruktor)
der Basisklasse.
Beispiel:
Von einem Flachdachhaus wird ein Modell
(Draufsicht) erstellt:
Der Einfachheit halber wird nur die Grundfläche (ohne Zimmer, usw.) des Hauses abgebildet.Aufgabe:Realsieren Sie die Klasse Modell in C++.
class Modell{ private: double l; double b;
public: Modell(double ll, double bb); void setL(double ll); void setB(double bb); double getL(); double getB(); double getFlaeche();}
Modell::Modell(double ll, double bb){l = ll;b = bb;
}
void Modell::setL(double ll){l = ll;
}
void Modell::setB(double bb){b = bb;
}
double Modell::getL(){return(l);
}
double Modell::getB(){return(b);
}
double Modell::getFlaeche(){return(l*b);
}
Jetzt soll ein “genaueres“ Modell des Flachdachhauses erstellt werden: Modell aus Styropor (oder Ton). Aufgabe:Realsieren Sie in C++ die Klasse Gmodell.
Wie kann man sich dabei Schreibarbeit sparen ? Wie kann man Softwareteile dabei wiederverwenden ?
Indem man die Vererbung benutzt.
Welche Member der Klasse Modell kann man übernehmen (erben) ?
Welche Member kommen neu dazu ?
class Modell{ private: double l; double b;
public: Modell(double ll, double bb); void setL(double ll); void setB(double bb); double getL(); double getB(); double getFlaeche();}
Alle außer dem Konstruktor
Welche Member werden vererbt ?
Welche Member müssen neu dazu ?
class Gmodell { private: double l;double l; double b;double b;
public:
void setL(double ll);void setL(double ll); void setB(double bb);void setB(double bb); double getL();double getL(); double getB();double getB(); double getFlaeche();double getFlaeche();
}
double h;
double getVolumen();
Die reliefförmig dargestellten Member werden geerbt.
Die rot dargestellten Member kommen neu dazu.
Wie wird eine Vererbung erreicht ?
:public Modell
void setH(double hh);double getH();
Gmodell(double ll, double bb, double hh);
Also sieht die Klasse folgendermassen aus:
class Gmodell:public Modell{ private: double h;
public: Gmodell(double ll, double bb, double hh); void setH(double hh); double getH(); double getVolumen();}
Die Methoden müssen noch außerhalb der Klassen implementiert werden.
Realisieren Sie die Methoden in C++
void Gmodell::setH(double hh){h = hh;
}
double Gmodell::getH(){return(h);
}
double Gmodell::getVolumen(){return(getFlaeche()*h);
}
Diese Methode wird von der Klasse Modell vererbt.
double Gmodell::getVolumen(){return(b*l*h);
}
Warum ist diese Lösung falsch ?
Es gibt Probleme mit dem Zugriffschutz (l und b sind private).Näheres dazu siehe später.
Gmodell::Gmodell(double ll, double bb, double hh): Modell(ll,bb){ setH(hh);}Da die Klasse Gmodell von der Klasse Modell erbt, muß beim Anlegen eines Objekts der Klasse Gmodell auch der Konstruktor der Klasse Modell aufgerufen werden.
Wird dies nicht gemacht, dann wird automatisch (ohne Zutun des Programmierers) der Standardkonstruktor der Klasse Modell aufgerufen.
Was passiert, wenn der Standardkonstruktor nicht existiert ?
Dann wird dieser automatisch vom Compiler angelegt, außer ....
es gibt einen Konstruktor mit (1, 2, 3, ...) Parametern.Dann liefert der Compiler eine Fehlermeldung.
Beispiel für die Benutzung der o.g. Klassen in einem
Hauptprogramm:
int main(){ Modell m(10,20); Gmodell g(2,3,4); double a,b,c, f, v; a = m.getL(); b = m.getB(); c = m.getH(); f = m.getFlaeche(); v = m.getVolumen(); a = g.getL(); b = g.getB(); c = g.getH(); f = g.getFlaeche(); v = g.getVolumen(); return 0;}
// a=10// b=20// syntaktisch falsch
// f=200
// a=2// b=3// c=4// f=6 // v=24
// synt. falsch
Verdeckte Member
class Gmodell:public Modell{ private: double h;
public: Gmodell(double ll, double bb, double hh); void setH(double hh); double getH(); double getVolumen(); double getFlaeche();}
Alles gleich wie vorher außer, daß eine Methode gleichen Namens wie in der Basisklasse existiert, die die Oberfläche des Modells (Quaders) berechnet. Wie muss sie implementiert werden ?
double Gmodell::getFlaeche(){ return(2*(getL()*getB()+getL()*h +getB()*h)); }
double Gmodell::getFlaeche(){ return(2*(l*b+l*h+b*h));}
Warum ist diese Lösung falsch ?
Es gibt Probleme mit dem Zugriffschutz (l und b sind private).Näheres dazu siehe später.
int main(){ Gmodell g(2,3,4); double f; f = g.getFlaeche();
return 0;
}
// f=6
Es wird auf die Methode der Unterklasse und nicht der Oberklasse zugegriffen, weil die Methode der Oberklasse durch die Methode der Unterklasse verdeckt wird.
Mit Angabe der Klasse und des sogenannten Scope Operators :: kann man auf die verdeckten Mitglieder zugreifen.
f = g.Modell::getFlaeche();
// f=52
Von welcher Klasse wird diese Methode aufgerufen ?
Darstellung der Vererbung durch UML
Basisklasse...
...
Subklasse...
...
Attribute
Methoden
Attribute
Methoden
Pfeil bedeutet: erbt von
Analog zum Zugriffsschutz +und - bedeutet # :Methode ist protected
Aufgabe:
Stellen Sie die Klassen Modell, Gmodell und ihre Vererbungshierarchie in UML dar.
Modell - l: double - b: double + Modell(double ll, double bb) + setL(double ll): void + setB(double bb): void + getL():double + getB():double + getFlaeche():double
Gmodell - h: double + Gmodell(double ll, double bb, double hh) + setH(double hh): void + getH():double + getVolumen():double
Statt dem Zugriffschutz + oder - kann auch der Zugriffschutz # (siehe später) benutzt werden.
Zugriffschutz (Zugriffsberechtigung) bei
Klassen
Bedeutung der Zugriffsarten:
Zugriff innerhalb einer Klasse bedeutet den Zugriff auf ein Member von innerhalb einer Methode der Klasse.
Beispiel:
void Modell::setL(double ll){ l = ll;}
Zugriff auf das Member setL
Zugriff außerhalb einer Klasse bedeutet den Zugriff auf ein Member von einem Objekt mit Hilfe des Punkts .
Beispiel:int main{ Modell m(2,8); m.setL(5); return 0;}
Zugriff auf das Member setL
Zugriffschutz (Zugriffsberechtigung) bei Klassen ohne Vererbung
Beispiel:
class Waisenkind{ private: int priWK;
protected: int proWK;
public: int pubWK;
void f_WK(){priWK=1; proWK; pubWK=3;
}};
int main(){ Waisenkind myWK; myWK.f_WK(); myWK.priWK=10; myWK.proWK=11; myWK.pubWK=12; return 0;}
Wo sind die Zugriffe ? Sind diese außerhalb/innerhalb ? Sind sie möglich ?
Zugriff außerhalb, möglich
Zugriff innerhalb, möglich
Zugriff innerhalb, möglich
Zugriff innerhalb, möglich
Zugriff außerhalb, unmöglich
Zugriff außerhalb, unmöglich
Zugriff außerhalb, möglich
class Waisenkind{ private: int priWK;
protected: int proWK;
public: int pubWK;
void f_WK(){priWK=1; proWK; pubWK=3;
}};
int main(){ Waisenkind myWK; myWK.f_WK(); myWK.priWK=10; myWK.proWK=11; myWK.pubWK=12; return 0;}
Welche Regel läßt sich daraus ableiten ?
Zugriff innerhalb ist auf private, protected und public Member möglich. Zugriff außerhalb ist nur auf public Member möglich.
Zugriffschutz (Zugriffsberechtigung) bei
Klassen mit Vererbung
Auf die nicht vererbten Member einer Klasse gilt die gleiche Regel wie vorher:Zugriff innerhalb ist auf private, protected und public Member möglich. Zugriff außerhalb ist nur auf public Member möglich.
Das Problem ist nur:Wie ist der Zugriffschutz (Zugriffsberechtigung) auf die vererbten Member einer Klasse geregelt ?
Zugriff auf die vererbten Member einer Klasse:
Aus Platzgründen muss im Folgenden auf die Trennung
von Deklaration und Implementierung der Methoden verzichtet
werden.
Beispiel:
class Mutter{ private: int priM;
protected: int proM;
public: int pubM;};
Zugriffsmanipulation der Member in der Basisklasse und ...
class Kind1:private Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
... Zugriffsmanipulation (der gesamten Basisklasse) bei der Vererbung der Klasse bestimmen die Zugriffsberechtigung:
Sind die Zugriffe auf die rotgedruckten Member in der Basisklasse möglich ?
protected
public
Insgesamt bestimmen also die "Schalter" Zugriffsmanipulation der Basisklasse und Zugriffsmanipulation der Member der Basisklasse die resultierende Zugriffsberechtigung.
private-Member:Zugriff nur von innerhalb der Klasse möglich
protected -Member:Zugriff von innerhalb der Klasse möglichZugriff von innerhalb einer abgeleiteten Klasse möglich
public -Member :Zugriff von innerhalb der Klasse möglichZugriff von innerhalb einer abgeleiteten Klasse möglichZugriff von außerhalb einer Klasse aus möglich
int main(){ Kind1 k1; k1.prifK(); k1.profK(); k1.pubfK(); k1.priM=105; k1.proM=109; k1.pubM=113; return 0;}
Bei welchen Anweisungen oben können Sie jetzt schon entscheiden, ob die Zugriffe erlaubt sind oder nicht ? Bei welchen können Sie noch nicht entscheiden ?
Um welche Zugriffe handelt es sich (innerhalb / außerhalb) ?
Zugriff von außerhalb auf ein nicht vererbtes private Member: nicht erlaubt
Zugriff von außerhalb auf ein nicht vererbtes protected Member: nicht erlaubt
Zugriff von außerhalb auf ein nicht vererbtes public Member: erlaubt
Die restlichen Zugriffe von außerhalb betreffen vererbte Member: bis jetzt noch nicht entscheidbar, muss noch geregelt werden...
private protected public
privatekein
Zugriffkein
Zugriffkein
Zugriff
protected private protected protected
public private protected public
Zugriffsberechtigung von der abgeleiteten Klasse auf die vererbten Member der Basisklasse :
Man sieht: Die Zugriffsberechtigung der Basisklasse kann durch die Klassenspezifikation vermindert, aber nicht vergrößert werden.
Member in Basisklasse
Vererbung Basisklasse
Sinn:Member von Klassen, die
z.B. für die Gestaltung einer grafischen Oberfläche vom
System zur Verfügung gestellt werden, sollen nicht durch eine Vererbung, die
ein Programmierer realisiert, vergrößert werden können.
Für die resultierende Zugriffsberechtigung für die vererbten Member gilt die gleiche Regel wie vorher:
Zugriff innerhalb ist auf private, protected und public Member möglich. Zugriff außerhalb ist nur auf public Member möglich. Wobei private, protected und public aus der vorigen Tabelle ermittelt werden müssen !!
Damit gilt dann für den Zugriff von der abgeleiteten
Klasse aus:
private protected public
private - - -
protected + + +
public + + +
+ bedeutet: Zugriff möglich- bedeutet: Kein Zugriff möglich (Compiler)
Member in Basisklasse
Vererbung Basisklasse
Damit gilt dann für den Zugriff von außerhalb:
private protected public
private - - -
protected - - -
public - - +
Member in Basisklasse
Vererbung Basisklasse
Gesamtergebnis:
R1) Zugriff auf ein vererbtes Member:a) Regel anwenden
R2) Zugriff auf ein nicht vererbtes Member:a) Resultierende Zugriffsberechtigung aus Tabelle ermittelnb) Regel anwenden
Zurück zur vorigen Aufgabe.
Welche Zugriffe sind möglich und warum ?(kein Zugriff bedeutet:
Fehlermeldung des Compilers)
class Mutter{ private: int priM;
protected: int proM;
public: int pubM;};
class Kind1:private Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
private + private = kein Zugriff (R2)
protected + private = private (R2)
public + private = private (R2)
private + private = kein Zugriff (R2)
protected + private = private (R2)
public + private = private (R2)
private + private = kein Zugriff (R2)
protected + private = private (R2)
public + private = private (R2)
int main(){ Kind1 k1; k1.prifK(); k1.profK(); k1.pubfK(); k1.priM=105; k1.proM=109; k1.pubM=113; return 0;}
Voraussetzungen: In der letzten Folie werden die Anweisungen, die keinen Zugriff verursachen und eine Compilermeldung bringen, entfernt.
no: private (R1)
no: protected (R1)
yes: public (R1)
no bedeutet : kein Zugriff möglich
yes bedeutet : Zugriff möglich
no: private + private = kein Zugriff (R2)
no: protected + private = private (R2)
no: public + private = private (R2)
Der Klassenzugriffschutz wird von private auf protected geändert.Was passiert ?
class Kind2:private Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
class Kind2: Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
class Kind2: Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profk(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
protectedprivate + protected = kein Zugriff (R2)
protected + protected = protected (R2)
public + protected = protected (R2)
private + protected = kein Zugriff (R2)
protected + protected = protected (R2)
public + protected = protected (R2)
private + protected = kein Zugriff (R2)
protected + protected = protected (R2)
public + protected = protected (R2)
int main(){ Kind2 k2; k2.prifK(); k2.profK(); k2.pubfK(); k2.priM=105; k2.proM=109; k2.pubM=113; return 0;}
Voraussetzungen: In der letzten Folie werden die Anweisungen, die keinen Zugriff verursachen und eine Compilermeldung bringen, entfernt.
no: private (R1)
no: protected (R1)
yes: public (R1)
no: private + protected = kein Zugriff (R2)
no bedeutet : kein Zugriff möglich
yes bedeutet : Zugriff möglich
no: protected + protected = protected (R2)
no: public + protected = protected (R2)
Der Klassenzugriffschutz wird von protected auf public geändert.Was passiert ?
class Kind3:protected Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
class Kind3: Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfK(){ priM=17; proM=18; pubM=19; }};
class Kind3: Mutter{ private: void prifK(){ priM=11; proM=12; pubM=13; }
protected: void profK(){ priM=14; proM=15; pubM=16; }
public: void pubfk(){ priM=17; proM=18; pubM=19; }};
publicprivate + public = kein Zugriff (R2)
protected + public = protected (R2)
public + public = public (R2)
private + public = kein Zugriff (R2)
protected + public = protected (R2)
public + public = public (R2)
private + public = kein Zugriff (R2)
protected + public = protected (R2)
public + public = public (R2)
int main(){ Kind3 k3; k3.prifK(); k3.profK(); k3.pubfK(); k3.priM=105; k3.proM=109; k3.pubM=113; return 0;}
Voraussetzungen: In der letzten Folie werden die Anweisungen, die keinen Zugriff verursachen und eine Compilermeldung bringen, entfernt.
no: private (R1)
no: protected (R1)
yes: public (R1)
no bedeutet : kein Zugriff möglich
yes bedeutet : Zugriff möglich
no: private + public = kein Zugriff (R2)
no: protected + public = protected (R2)
yes: public + public = public (R2)
Konstruktoren, Destruktoren bei der Vererbung
Beispiel:
class BasisKlasse{ public: BasisKlasse(int i); ~BasisKlasse();}; BasisKlasse::BasisKlasse(int i){ cout << "Aufruf Konstr. BK \n");}; BasisKlasse::~BasisKlasse(){ cout << "Aufruf Destr. BK \n");};
class SubKlasse:public BasisKlasse{
public: SubKlasse(int i); ~SubKlasse();}; SubKlasse::SubKlasse(int i): BasisKlasse(i){ cout << "Aufruf Konstr. SK \n");};
SubKlasse::~SubKlasse(){ cout << "Aufruf Destr. SK \n");};
// Welche Ausgaben werden auf dem // Bildschirm erzeugt ?
int main(){ SubKlasse s(1); return 0;}
Aufruf Konst. BKAufruf Konst. SKAufruf Destr. SKAufruf Destr. BK
Es gilt des weiteren:
Wenn der Konstruktor der Subklasse nicht (weil es der Programmierer vergessen hat zu implementieren) einen Konstruktor der Basisklasse aufruft, dann ruft er automatisch den Standardkonstruktor der Basisklasse auf.
Der Destruktor in der Subklasse ruft automatisch den Destruktor der Basisklasse auf.Wenn der Destruktor der Subklasse nicht implementiert wird, wird er automatisch vom Compiler erzeugt. Dieser automatisch erzeugte Destruktor ruft dann auch den Destruktor der Basisklasse auf.
Wann soll man eine Vererbung sinnvoll
einsetzen ?
wenn die folgende Beziehung besteht:
Subklasse "ist ein(e)"
Basisklasse.
Beispiele der Vererbung:Ein LKW ist ein FahrzeugEine Katze ist ein TierEine Tulpe ist eine Pflanze
abgeleitete Klasse
Basisklasse
Der Prozeß, um von einer Basisklasse durch Detaillierung und Konkretiserung zu einer Subklasse zu kommen, nennt man Spezialisierung.
Der Prozeß, um von einer Subklasse durch Verallgemeinerung und Abstraktion zur Basisklasse zu kommen, nennt man Generalisierung.