Einführung in C# Teil 3. Matthias Nübling

Transkript

1 Einführung in C# Teil 3 Matthias Nübling

2 Vorausgesetzte Grundkenntnisse Programmierung Typen, Variablen, Anweisungen, Funktionen, etc. Objektorientierte Programmierung Klassen, Vererbung, Polymorphismus, dynamische Bindung, etc. Praktische Erfahrung in C++ oder Java

3 Inhalt Vererbung Interfaces

4 Klassenhierarchie und Vererbung Klassen können in einer Klassen- bzw. Vererbungshierarchie angeordnet werden Oberklasse = Basisklasse; Unterklasse = abgeleitete Klasse Vererbung der Eigenschaften (Datenelemente und Funktionselemente) einer Oberklasse an alle Unterklassen Hinzufügen weiterer Eigenschaften in Unterklassen möglich Überschreiben oder Verdecken von Funktionselementen in Unterklassen möglich

5 Klassenhierarchie und Vererbung Eine Klasse kann nur von einer Oberklasse abgeleitet sein. Sie kann aber mehrere Interfaces implementieren Structs können weder erben noch vererben. Sie können aber mehrere Interfaces implementieren Alle Klassen sind direkt oder indirekt von abgeleitet. Structs sind über Boxing zu kompatibel Klassenelemente können die Sichtbarkeitsattribute,,, oder haben

6 Vererbung public public class class A { int inta; a; public public void void F() F() { { public public class class B: B: A { int intb; b; public public void void G() G() { { A a = new new A(); A(); // // statischer statischertyp: A; A; dynamischer dynamischertyp: Typ: A a = new new B(); B(); // // statischer statischertyp: A; A; dynamischer dynamischertyp: Typ: B a.f(); a.f(); // // OK OK a.g(); a.g(); // // Compiler-Fehler Compiler-Fehler B b = new new B(); B(); // // statischer statischertyp: B; B; dynamischer dynamischertyp: Typ: B b.f(); b.f(); // // OK OK b.g(); b.g(); // // OK OK

7 Sichtbarkeitsattribute Sichtbarkeitsattribut Sichtbarkeit überall (wo auch deklarierender Namespace bekannt ist) nur innerhalb des gleichen Typs (default bei Klasse und Struct) nur innerhalb des gleichen Typs und aller abgeleiteten Typen nur innerhalb des Assemblies (default bei äußeren Typen) oder

8 Sichtbarkeitsattribute public public class class A { protected protectedint inta; a; public public void void F() F() { { public public class class B: B: A { public publicint intb; b; public public void void G() G() { a = 10; 10; // // OK OK da daprotected Console.WriteLine("a={0,b={1", a, a, b); b); B b = new new B(); B(); b.a b.a = 20; 20; // // Compiler-Fehler Compiler-Fehlerda daprotected b.b b.b = 20; 20; // // OK OK da dapublic b.g(); b.g(); // // a=10,b=20 a=10,b=20

9 Typ-Operationen : Prüft, ob der dynamische Typ von der Variablen v kompatibel zum Typ T ist : Typumwandlung (Casting). Falls v nicht kompatibel zu T ist, wird eine Exception geworfen : Typumwandlung. Falls v nicht kompatibel zu T ist, wird zurückgegeben A a = new new B(); B(); Console.WriteLine(a is isb); // // true true Console.WriteLine(a is isa); // // true, true, aber aberwarning B b = (B) (B) a; a; // // OK OK b = a as asb; B; Console.WriteLine(b is isb); // // true, true, aber aberwarning!

10 Typ-Operationen gibt den Laufzeittyp einer Instanz als System.Type-Objekt zurück Der -Operator gibt das System.Type- Objekt eines Typs zurück A a = new new B(); B(); Type Type t = a.gettype(); a.gettype(); Console.WriteLine(t.Name); // // B t = typeof(b); typeof(b); Console.WriteLine(t.Name); // // B "

11 Überschreiben von Methoden Methoden mit gleicher Schnittstelle können überschrieben werden Überschreibbare Methode muß als deklariert werden, überschreibende als Schnittstelle beinhaltet Parameteranzahl, Parametertypen, Rückgabetyp und Sichtbarkeitsattribut (public, protected,...) Das Überschreiben von Methoden ermöglicht die dynamische Bindung beim Aufruf Auch Properties und Indexers können überschrieben werden Statische Methoden können nicht überschrieben werden ""

12 Überschreiben von Methoden public public class class A { public public virtual virtualvoid void F() F() { Console.WriteLine("A::F"); public public class class B: B: A { public public override overridevoid void F() F() { Console.WriteLine("B::F"); A a = new new B(); B(); a.f(); a.f(); // // B::F B::F (Dynamische (DynamischeBindung) "

13 Verdecken von Methoden Methoden mit gleicher Schnittstelle können auch verdeckt werden Verdeckende Methode muß als deklariert werden Schnittstelle beinhaltet Parameteranzahl und Parametertypen. Der Rückgabetyp kann unterschiedlich sein Beim Verdecken findet immer statische Bindung statt Das Verdecken ist auch bei folgenden Elementen möglich: Properties und Indexers Statische Methoden Gleichnamige Felder. Hier können die Typen unterschiedlich sein "

14 Verdecken von Methoden public public class class A { public public void void F() F() { Console.WriteLine("A::F"); public public class class B: B: A { public public new newint intf() { Console.WriteLine("B::F"); A a = new new B(); B(); a.f(); a.f(); // // A::F A::F (Statische (StatischeBindung) "

15 Überladen von Methoden Gleichnamige Methoden mit unterschiedlicher Schnittstelle überladen sich Überladene Methoden müssen nicht als deklariert werden Schnittstelle beinhaltet Parameteranzahl und Parametertypen (ohne Rückgabetyp) Beim Überladen findet immer statische Bindung statt "

16 Überladen von Methoden public public class class A { public public void void F(double F(doublef) f) { Console.WriteLine("A::F:" + f); f); public public class class B: B: A { public public void void F(int F(inti) i) { Console.WriteLine("B::F:" + i); i); A a = new new B(); B(); a.f(5); a.f(5); // // A::F A::F (statische (statischebindung) B b = new new B(); B(); b.f(5.5); b.f(5.5); // // A::F A::F (statische (statischebindung) "

17 Basisklasse (base) Mit dem Schlüsselwort kann man auf verdeckte Elemente der Basisklasse zugreifen class class Shape Shape { int intx, x, y; y; public public override override string string ToString() ToString() { return return "x=" "x=" + x + ",y=" ",y=" + y; y; class class Circle Circle : Shape Shape { int intr; r; public public override override string string ToString() ToString() { return return base.tostring() base.tostring() + ",r=" ",r=" + r; r; "

18 Konstruktoren Konstruktoren werden nicht vererbt Eine Unterklasse kann einen Konstruktor der Basisklasse mit aufrufen Wird nicht verwendet, so wird automatisch der parameterlose Default-Konstruktor der Basisklasse aufgerufen Achtung: Hat eine Klasse keinen Konstruktor, wird implizit ein parameterloser Default-Konstruktor angelegt. Hat sie aber einen Konstruktor, wird kein Default-Konstruktor angelegt. D.h. dieser müßte in diesem Fall explizit definiert werden Der Destruktor der Basisklasse wird am Schluß immer automatisch aufgerufen "

19 Konstruktoren class class Shape Shape { int intx, x, y; y; public public Shape(): Shape(): this(0, this(0, 0){ 0){ public public Shape(int Shape(intx, x, int inty) y) {this.x {this.x = x; x; this.y this.y = y; y; class class Circle: Circle: Shape Shape { int intr; r; public public Circle() Circle() {this.r {this.r = 1; 1; public public Circle(int Circle(intx, x, int inty, y, int intr): base(x, base(x, y) y) { this.r this.r = r; r; Circle Circle c = new new Circle(); Circle(); Console.WriteLine(c); // // x=0,y=0,r=1 x=0,y=0,r=1 c = new new Circle(100, Circle(100, 100, 100, 50); 50); Console.WriteLine(c); // // x=100,y=100,r=50 x=100,y=100,r=50 "!

20 Abstrakte Klassen Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann Sie dient als Basisklasse für andere Klassen Sie ist ähnlich zu einem Interface Sie kann abstrakte und nicht-abstrakte Methoden enthalten Abstrakte Methoden haben keinen Anweisungsteil Abstrakte Methoden sind implizit Abstrakte Klassen und Methoden werden mit dem Schlüsselwort deklariert Auch Properties und Indexers können abstrakt sein

21 Abstrakte Klassen abstract abstractclass class Shape Shape { protected protected int intx, x, y; y; public public Shape(int Shape(intx, x, int inty) y) {this.x {this.x = x; x; this.y this.y = y; y; public public abstract abstractvoid Draw(); Draw(); class class Circle: Circle: Shape Shape { protected protected int intr; r; public public Circle(int Circle(intx, x, int inty, y, int intr): base(x, base(x, y) y) {this.r {this.r = r; r; public public override overridevoid void Draw() Draw() { Console.WriteLine("Drawing at at ({0,{1), ({0,{1), r={2", r={2", x, x, y, y, r); r); Shape Shape s = new new Circle(100, Circle(100, 100, 100, 50); 50); s.draw(); s.draw(); // // Drawing Drawing at at (100,100), (100,100), r=50 r=50 "

22 Versiegelte Klassen Eine versiegelte Klasse ist eine Klasse, die nicht als Basisklasse verwendet werden kann Verwendung des -Schlüsselwortes sealed sealedclass Circle: Circle: Shape{ Shape{ Versiegelte Klassen können nicht gleichzeitig abstrakt sein Alle Structs sind implizit versiegelt Es lassen sich statt ganzer Klassen auch einzelne Methoden, Properties und Indexer versiegeln Gründe für versiegelte Klassen und Methoden: Sicherheit: Semantik kann nicht durch Überschreiben von Methoden verändert werden Code-Optimierung: u. U. statische statt dynamische Bindung möglich

23 Interface Ein Interface definiert einen Typ. Dieser definiert nur eine Schnittstelle und enthält kein Code. Ein Interface kann die Deklarationen folgender Elemente enthalten: Methoden Properties Indexer Events Interface-Elemente sind implizit Interface-Elemente dürfen nicht sein

24 Interfaces Wird ein Interface von einer Klasse oder einem Struct implementiert, so muß es als Ganzes implementiert werden. Jede geerbte Interface- Methode (Property, Indexer) muß entweder implementiert oder von einer anderen Klasse geerbt werden Beim Überschreiben von Interface- Methoden darf man kein angeben, außer man überschreibt eine von einer Klasse geerbte Methode Beim Überschreiben von Interface- Methoden darf man oder angeben (d. h. ein Interface darf durch eine abstrakte Klasse implementiert werden)

25 Interface Implementierung Interface- Implementierung Vererbung!"#

26 Interface Implementierung interface interfaceistorable { void void Open(); Open(); void void Change(); Change(); void void Save(); Save(); DocumentStatus DocumentStatusStatus { get; get; set; set; public public class class Document: Document: IStorable IStorable { public public virtual virtual void void Open() Open() { { public public void void Change() Change() { { public public virtual virtual void void Save() Save() { { public public DocumentStatus DocumentStatusStatus { get get { { set set { {

27 Interface Verwendung Document Document d = new new Document("My Document("MyDocument"); Document"); d.open(); d.open(); d.change(); d.change(); IStorable IStorables = d as as IStorable; IStorable; if if (s (s!=!= null) null) { s.save(); s.save();

28 Interfaces Eine Klasse kann nur von einer Klasse erben, aber beliebig viele Interfaces implementieren Interfaces können andere Interfaces durch Ableitung erweitern Interfaces ermöglichen Polymorphismus: Unterschiedliche Klassen können das gleiche Interface implementieren Eine Variable kann von einem Interface-Typ sein

29 Interface Implementierung!#!"#!"#!"#!"# $% $% & &!

30 Beispiel: Documents

31 Nameskonflikte Ein Nameskonflikt tritt auf, wenn eine Klasse zwei Interfaces implementiert, die beide gleichnamige Methoden enthalten Alternativen: 1) Die Klasse stellt eine Implementierung für beide Interface-Methoden zur Verfügung 2) Die Klasse stellt für jede der beiden Methoden eine Implementierung zur Verfügung. Hier sind die Methodennamen mit dem Interface-Namen zu qualifizieren (siehe Beispiel) "

32 Nameskonflikte (Alternative 2) interface interfacei1 I1 { void void F(); F(); interface interfacei2 I2 { void void F(); F(); class class A: A: I1, I1, I2 I2 { void void I1.F() I1.F() {Console.WriteLine("I1.F"); void void I2.F() I2.F() {Console.WriteLine("I2.F"); A a = new new A(); A(); a.f(); a.f(); // // Compiler-Fehler Compiler-Fehler I1 I1 i1 i1 = a; a; i1.f(); i1.f(); // // I1.F I1.F I2 I2 i2 i2 = a; a; i2.f(); i2.f(); // // I2.F I2.F

33 Fragen? Uff...