Klassenbeziehungen & Vererbung

Transkript

1 Klassenbeziehungen & Vererbung VL Objektorientierte Programmierung Raimund Kirner teilweise nach Folien von Franz Puntigam, TU Wien

2 Überblick Arten von Klassenbeziehungen Untertypen versus Vererbung in C++ Klassenattribute in C++ Verschachtelte Klassen Mehrfachvererbung 2

3 Grundkonzepte von OOP Objektorientierte Programmierung ist oft definiert als die Kombination von: 1. Abstrakten Datentypen (ADT) zwischen manchen ADTs gilt das Ersetzbarkeitsprinzip. (Untertypen von Typ T anstelle von Typ T verwendbar) 2. Vererbung stellt eine Halbordnungsbeziehung zwischen Klassen dar. 3. Dynamisches Binden (Implementierungsentscheidungen bis zur Laufzeit verschoben) stellt eine Erweiterung der Vererbungskonzeptes dar. Jedes der obigen Konzepte stellt ein eigenes Konzept zur Unterteilung von Systemen dar. 3

4 Arten von Klassenbeziehungen Vererbungsbeziehung: Elemente (Attribute, Methoden, etc.) der Klasse teilweise von Basisklasse(n) übernommen Ersetzbarkeit irrelevant Untertypbeziehung: Ersetzbarkeit Vererbung von Code aus Basisklasse irrelevant spiegelt sog. ist-ein (engl. is-a ) Beziehung der realen Welt wider Regel: Wiederverwendung durch das Ersetzbarkeitsprinzip ist wesentlich wichtiger als direkte Wiederverwendung durch Vererbung 4

5 Arten von Klassenbeziehungen (2) ist implementiert mit -Beziehung Objektkomposition (Einbettung) private Vererbung (eher nur dann zu verwenden, wenn Objektkomposition nicht möglich mangels Zugriffsmöglichkeit auf geschützte Elemente der Klasse) hat ein(e) -Beziehung (oder ist Teil von -Beziehung) Objektkomposition (Einbettung) Objekt Aggregation (Objekte können auch getrennt existieren, ansonsten wäre es Objektkomposition) 5

6 Darstellung der Klassenbeziehungen in UML ist-ein (public Vererbung) ist-implementiert mit (mittels privater Vererbung) «private» object composition object aggregation n n 6

7 Vererbung Bedingter Code-Reuse Auch wenn die Methode der Basisklasse nicht die volle Funktionalität der abgeleiteten Klasse implementiert, kann Code Reuse sinnvoll sein: class A { public: virtual void setlevel(int n); }; class B : public A { protected: bool m_flag; public: virtual void setlevel(int n) { if (m_flag==true) A::setLevel(n); } }; 7

8 Vererbung Reuse mit Faktorisierung Es kann der Fall sein, dass sich eine Methode in Basisklasse und abgeleiteter Klasse geringfügig unterscheiden, sodass kein direkter Code-Resue möglich ist: class A { public: virtual void foo(void) { if ( ) { } else { ; x=1; } } }; class B : public A { public: virtual void foo(void) { if ( ) { } else { ; x=2; } }; 8

9 Vererbung Reuse mit Faktorisierung (2) Um in diesem Fall Code Reuse zu erhöhen, kann man die Methode aufspalten: class A { class B : public A { public: protected: virtual void foo(void) { virtual void foo2() { ; x=2; } if ( ) { } else { foo2(); } } }; protected: virtual void foo2() { ; x=1; } }; 9

10 Vererbung Reuse mit Faktorisierung (3) Mittels der Template-Method (Design Pattern) braucht nur ein Teil der Methode überschrieben werden: class A { public: virtual void foo(void) { foox(1); } protected: virtual void foox(int y) { if ( ) { } else { ; x=y; } } }; class B : public A { public: virtual void foo(void) { foox(2); } }; 10

11 Klassenattribute in C++ Instanzvariablen (für jede Instanz eigene Variable): int m_count; (Info: Default-Wertzuweisung nur über Konstruktor) Klassenvariablen (Variable 1x vorhanden in Klasse): static int m_max; (Achtung: Eine Klassenvariable muss explizit definiert werden, z.b.: int ClassX::m_max = 0;) Konstanten (nicht beschreibbar): const int MAX_SIZE = 255; (Aber: mutable -Anweisung, um einzelne Elemente in const-klasse als änderbar zu deklarieren) 11

12 Verschachtelte Klassen Innerhalb einer Klasse kann eine weitere Klasse definiert werden ( verschachtelte Klassen): class Aussen { public: class Innen { }; }; Die äußere Klasse kann auf die innere Klasse nur über die öffentliche Schnittstelle zugreifen (Ausnahme: friend-deklaration) 12

13 Verschachtelte Klassen (2) Wenn von der inneren Klasse auf private Elemente der äußeren Klasse zugegriffen werden soll, muss dies laut aktuellen C++ Standard (1998) explizit mittels der friend-deklaration spezifiziert werden: class Aussen { public: class Innen; friend class Innen; class Innen { }; }; Im nächsten C++ Standard wird diese friend-deklaration aber nicht mehr notwendig sein, da man Innen auch als ein Element von Aussen betrachtet und daher Zugriff auf private Elemente von Aussen haben sollte. 13

14 Verschachtelte Klassen (3) Wenn Innen im öffentlichen Bereich von Aussen definiert wird, wie beispielsweise class Aussen { public: class Innen { }; }; dann kann man neben Aussen auch von Innen ein Objekt instantiieren: Aussen a; Aussen::Innen i; 14

15 Mehrfachvererbung Mehrfachvererbung liegt vor, wenn eine Klasse von mehr als einer Basisklasse erbt. Vorteile: Untertypsbeziehungen mit mehr als einem Obertyp direkt ausdrückbar. Nachteile: resultiert meistens in kompliziertes (schwer durchschaubares) Systemdesign Nicht viele Sprachen unterstützen Mehrfachvererbung: z.b.: C++, Python, Eiffel Manche Sprachen umgehen Probleme der Mehrfachvererbung, in dem man die Implementierung mehrerer Interfaces anstelle von Mehrfachvererbung benutzt: z.b.: Java, C#, Delphi, VB (.net) 15

16 Mehrfachvererbung (2) Problem von Mehrfach-vererbung: sog. Diamond-Problem : Beispiel: In C++ werden bei normaler (nicht virtueller) Vererbung für D zwei Instanzen von A angelegt! Zugriff auf Attribut m_a in D muss qualifiziert werden: B::m_a bzw. C::m_a B A m_a D C 16

17 Mehrfachvererbung (3) Diamond-Problem : Durch virtuelles Ableiten in B,C wird in Subklasse D nur eine Kopie von A erzeugt: class B: virtual public A { }; class C: virtual public A { }; Zugriff auf Attribut m_a in D darf nun unqualifiziert sein: m_a = 5; B A m_a {overlapping} D C 17

18 Mehrfachvererbung (4) Ob Mehrfachvererbung eingesetzt werden soll oder nicht, lässt sich schwer generell sagen. Zumindest aber sollte man Mehrfachvererbung vermeiden, wenn dies leicht möglich ist. Mehrfachvererbung lässt sich beispielsweise durch das Twin-Pattern vermeiden [Mössenböck,1999]: anstelle beispielsweise Klasse C von A und von B abzuleiten, werden zwei separate Klassen Ca und Cb benutzt, wobei Ca von A und Cb von B abgeleitet ist. Zugleich sind Ca und Cb miteinander verbunden (Zwillinge). 18

19 Überschreiben von Methoden Überschreiben einer Methode bedeutet, dass eine Methode einer Basisklasse in einer abgeleiteten Klasse mit derselben Signatur (gleicher Name und Argumente) definiert wird Überschreiben kann sowohl auf statischer wie auch auf dynamischer Bindung basieren: statisch (default in C++): überschreiben von nicht-virtuellen Methoden dynamisch: überschreiben von virtuellen Methoden Schlüsselwort virtual 19

20 Überladen von Methoden Überladen von Methoden/Funktionen bedeutet, dass eine Methode/Funktion mehrfach mit gleichem Namen aber unterschiedlichen Argumenten im selben Bezugsrahmen definiert wird Überladen ist kein spezifisches Konzept der objektorientierten Programmierung, z.b.: Operator / unterschiedlich für Integer- und Float-Typen Überladen benutzt statische Bindung (der deklarierte Typ dem Funktionsaufruf entscheidet darüber, welche Funktion tatsächlich aufgerufen wird) 20

21 Überladen von Methoden (2) class A { public: void setstate(float v); void setstate(int v); }; A a; //Aufruf 1. Methode: a.setstate(0.5); //Aufruf 2. Methode: a.setstate(4); class T1 : public T2 { } class B { public: void setstate(t1 v); void setstate(t2 v); }; statische Bindung B b; T1 t = new T2; // Aufruf der 1. Methode!!!!! b.setstate(t); 21

22 Überladen von Methoden (3) Empfehlungen zum Überladen: Überladen ist generell fehleranfällig wenn möglich, vermeiden Überladen in verschiedenen Klassen schwer überschaubar Überladen von Methoden der Basisklasse stets vermeiden Für je zwei überladene Methoden soll gelten: Unterscheidung anhand einer Parameterposition, wobei Parametertypen keinen gemeinsamen Untertyp haben oder alle Parametertypen einer Methode spezieller als die der anderen, und allgemeinere Methode verzweigt nur auf speziellere, falls möglich 22

23 Multi-Methoden Syntaktisch gleich wie Überladen von Methoden, jedoch wird dynamische Bindung bei der Methodenauswahl anhand der Argumente eingesetzt class T2 : public T1 { } class B { public: void setstate(t1 v); void setstate(t2 v); }; nicht in C++! dynamische Bindung B b; T1 t = new T2; // Aufruf der 2. Methode!!!!! b.setstate(t); 23

24 Simulation von Multi-Methoden In Sprachen die keine Multi-Methoden unterstützen (wie etwa C++), kann man Multi-Methoden simulieren, indem man die Methoden von der ursprünglichen Klasse in die Klassen der Argumente der ursprünglichen Methode verlegt, mit folgenden Anpassungen: anstelle der dynamischen Bindung benutzt man unterschiedliche Namen für Methoden es müssen alle Möglichkeiten der ansonsten dynamischen Bindung bei der Simulation mittels statischer Bindung durch eigene Methoden explizit programmiert werden viel mehr Code notwendig! 24

25 Simulation von Multi-Methoden (2) class A { public: virtual void setstate(t0 v) = 0; }; class B : public A { public: virtual void setstate(t0 v) {v.setstate_b(this);} }; class C : public A { public: virtual void setstate(t0 v) {v.setstate_c(this);} }; class T0 { public: virtual void setstate_b(b& v) = 0; virtual void setstate_c(c& v) = 0; }; class T1 : public T0 { public: virtual void setstate_b(b& v); virtual void setstate_c(c& v); }; class T2 : public T0 { public: virtual void setstate_b(b& v); virtual void setstate_c(c& v); }; 25