Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 4 Vererbung, Polymorphie und Interfaces
Pfeil 4.1 Die Vererbung
Pfeil 4.1.1 Basisklassen und abgeleitete Klassen
Pfeil 4.1.2 Ableitung einer Klasse
Pfeil 4.1.3 Klassen, die nicht abgeleitet werden können
Pfeil 4.1.4 Konstruktoren in abgeleiteten Klassen
Pfeil 4.1.5 Der Zugriffsmodifizierer »protected«
Pfeil 4.1.6 Konstruktorverkettung in der Vererbung
Pfeil 4.2 Der Problemfall geerbter Methoden
Pfeil 4.2.1 Geerbte Methoden mit »new« verdecken
Pfeil 4.2.2 Abstrakte Methoden
Pfeil 4.2.3 Virtuelle Methoden
Pfeil 4.3 Typumwandlung und Typuntersuchung von Objektvariablen
Pfeil 4.3.1 Implizite Typumwandlung von Objektreferenzen
Pfeil 4.3.2 Explizite Typumwandlung von Objektreferenzen
Pfeil 4.3.3 Typuntersuchung mit dem is-Operator
Pfeil 4.3.4 Typumwandlung mit dem as-Operator
Pfeil 4.4 Polymorphie
Pfeil 4.4.1 »Klassische« Methodenimplementierung
Pfeil 4.4.2 Abstrakte Methoden
Pfeil 4.4.3 Virtuelle Methoden
Pfeil 4.4.4 Versiegelte Methoden
Pfeil 4.4.5 Überladen einer Basisklassenmethode
Pfeil 4.4.6 Statische Member und Vererbung
Pfeil 4.5 Das Projekt »GeometricObjectsSolution« ergänzen
Pfeil 4.6 Hat-ein(e)-Beziehungen
Pfeil 4.6.1 Innere Klassen (Nested Classes)
Pfeil 4.7 Interfaces (Schnittstellen)
Pfeil 4.7.1 Schnittstellendefinition
Pfeil 4.7.2 Schnittstellenimplementierung
Pfeil 4.7.3 Interpretation der Schnittstellen
Pfeil 4.8 Das Zerstören von Objekten – der Garbage Collector
Pfeil 4.8.1 Arbeitsweise des Garbage Collectors
Pfeil 4.8.2 Expliziter Aufruf des Garbage Collectors
Pfeil 4.8.3 Der Destruktor
Pfeil 4.8.4 Die »IDisposable«-Schnittstelle
Pfeil 4.8.5 Ergänzungen in den Klassen »Circle« und »Rectangle«


Galileo Computing - Zum Seitenanfang

4.3 Typumwandlung und Typuntersuchung von Objektvariablen Zur nächsten ÜberschriftZur vorigen Überschrift


Galileo Computing - Zum Seitenanfang

4.3.1 Implizite Typumwandlung von Objektreferenzen Zur nächsten ÜberschriftZur vorigen Überschrift

Die Klasse Luftfahrzeug beschreibt Eigenschaften und Operationen, die allen Luftfahrzeugen, unabhängig vom Typ, eigen sind. Die Klassen Zeppelin, Flugzeug und Hubschrauber beerben als abgeleitete Klassen die Basisklasse.

Betrachten wir einen Ausschnitt der Klassenhierarchie, nämlich die beiden Klassen Zeppelin und Luftfahrzeug. Wenn wir unsere Erkenntnisse aus der realen Welt auf unseren Code projizieren, kommen wir zu der Aussage, dass ein Zeppelin ein Luftfahrzeug ist. Andererseits ist aber ein Luftfahrzeug nicht zwangsläufig ein Zeppelin, denn es könnte sich auch um ein Flugzeug oder einen Hubschrauber handeln. Die Tatsache, dass das Objekt einer abgeleiteten Klasse (hier Zeppelin) auch gleichzeitig ein Objekt der Basisklasse (hier Luftfahrzeug) ist, wird als Ist-ein(e)-Beziehung bezeichnet. Diese Aussage ist nicht neu, sie wurde bereits am Anfang dieses Kapitels gemacht.

Die Vererbung hat Konsequenzen hinsichtlich der Zuweisungsoperationen, denn aufgrund dieser Beziehung kann man die Referenz eines Subklassenobjekts einer Basisklassenreferenz zuweisen:


Zeppelin zpln = new Zeppelin();
Luftfahrzeug lfzg = zpln;

Stehen zwei Klassen miteinander in einer Vererbungsbeziehung, kann eine Referenz vom Typ der abgeleiteten Klasse der Referenz vom Typ einer der Basisklassen mit


Basisklassenreferenz = Subklassenreferenz

zugewiesen werden. Dabei wird implizit konvertiert.

Die beiden Variablen zpln und lfzg referenzieren denselben Speicherbereich – jedoch mit einer kleinen Einschränkung: Die Laufzeitumgebung betrachtet lfzg nur als Objekt vom Typ Luftfahrzeug und nicht als Zeppelin. Damit hat die Objektreferenz lfzg auch keinen Zugriff auf die Member, durch die sich ein Objekt vom Typ Zeppelin auszeichnet.

Bei einer Zuweisung einer Subklassenreferenz an eine Basisklassenreferenz müssen alle Member der links vom Zuweisungsoperator angegebenen Referenz einen konkreten Bezug zu einem Mitglied der Referenz haben, die rechts vom Zuweisungsoperator steht. Betrachten Sie dazu Abbildung 4.5, die diesen Sachverhalt veranschaulicht. Dass dabei das Feld Gasvolumen einer Zeppelin-Referenz keinen Abnehmer in der Luftfahrzeug-Referenz findet, spielt keine Rolle.

Abbildung 4.5 Zuweisung einer Subklassenreferenz an eine Basisklassenreferenz

Die Tatsache, dass ein Objekt vom Typ einer abgeleiteten Klasse auch gleichzeitig ein Objekt vom Typ seiner Basisklasse ist, kann man sich bei der Typfestlegung eines Parameters zunutze machen:


public void TestProc(Luftfahrzeug lfzg) {
  ...
}

Die Methode TestProc erwartet vom Aufrufer die Referenz auf ein Luftfahrzeug. Ob es sich dabei um ein Objekt vom Typ Zeppelin, Hubschrauber oder Flugzeug handelt, spielt keine Rolle. Ausschlaggebend ist ausschließlich, dass der Typ der übergebenen Referenz von Luftfahrzeug abgeleitet ist. Zeppelin erfüllt diese Bedingung. Daher kann die Methode TestProc folgendermaßen aufgerufen werden:


Zeppelin zpln = new Zeppelin();
IrgendEinObjekt.TestProc(zpln);

Parameter vom Typ einer Basisklasse werden häufig dann eingesetzt, wenn unabhängig vom genauen Typ innerhalb der Methode auf ein in der Basisklasse definiertes Member zugegriffen wird. Beispielsweise könnte man sich vorstellen, dass in TestProc die Methode Starten des übergebenen Objekts aufgerufen wird:


public void TestProc(Luftfahrzeug lfzg) {
  ...
  lfzg.Starten();
  ...
}

Da sowohl ein Flugzeug- als auch ein Zeppelin- oder Hubschrauber-Objekt über diese Methode verfügt, ist diese TestProc eine hinsichtlich der Luftfahrzeuge allgemein gehaltene Methode. Das erspart Ihnen, drei verschiedene Methoden TestProc zur Verfügung zu stellen. Denn genau das müssten Sie machen, gäbe es die implizite Konvertierung und Vererbung nicht. Zudem ist auch sichergestellt, dass die Methode TestProc bei einer späteren Erweiterung der Vererbungshierarchie, beispielsweise durch eine Klasse Rakete, auch mit einem Objekt vom Typ Rakete einwandfrei funktioniert.


Galileo Computing - Zum Seitenanfang

4.3.2 Explizite Typumwandlung von Objektreferenzen Zur nächsten ÜberschriftZur vorigen Überschrift

Wenn es erforderlich ist, können Sie auch eine Basisklassenreferenz in eine Subklassenreferenz konvertieren. Also:


Zeppelin zep = new Zeppelin();
Luftfahrzeug lfzg = zep;
...
Zeppelin flg = (Zeppelin)lfzg;

Bei der expliziten Typumwandlung gilt die folgende Regel:


Subklassenreferenz = (Zieldatentyp)Basisklassenreferenz

Den Zieldatentyp geben Sie in runden Klammern vor der umzuwandelnden Referenz an. Der Erfolg der Typumwandlung setzt allerdings voraus, dass vorher eine implizite Konvertierung des Subklassentyps in den Typ der Basisklasse stattgefunden hat. Die explizite Konvertierung ist demnach die Umkehrung der impliziten Konvertierung, die nur dann erfolgt, wenn sich die Ausgangs- und Zieldatentypen in einer Vererbungsbeziehung befinden.

Die explizite Konvertierung innerhalb einer Vererbungshierarchie auf horizontaler Ebene in einer Klassenhierarchie, beispielsweise eine Konvertierung vom Typ Flugzeug in den Typ Hubschrauber, ist nicht gestattet.


Galileo Computing - Zum Seitenanfang

4.3.3 Typuntersuchung mit dem is-Operator Zur nächsten ÜberschriftZur vorigen Überschrift

Manchmal ist es notwendig, den Typ festzustellen, der sich hinter einer Basisklassenreferenz verbirgt, beispielsweise dann, wenn in Abhängigkeit vom tatsächlichen Typ bestimmte Operationen ausgeführt werden sollen oder ein typspezifisches Member aufgerufen werden soll. Zur Lösung dieser Aufgabe bietet uns C# den is-Operator an.

Sehen wir uns dazu ein konkretes Beispiel an, und nehmen wir an, in der Methode TestProc soll in Abhängigkeit vom übergegebenen Typ entweder die Spannweite, das Gasvolumen oder der Rotordurchmesser ausgegeben werden. Wir müssen dann die Methode wie folgt ergänzen:


public void TestProc(Luftfahrzeug lfzg) {
  if (lfzg != null) {
    if (lfzg is Flugzeug)
      Console.WriteLine("Spannweite: ", ((Flugzeug)lfzg).Spannweite);
    else if (lfzg is Zeppelin)
      Console.WriteLine("Gasvolumen: ", ((Zeppelin)lfzg).Gasvolumen);
    else if (lfzg is Hubschrauber)
      Console.WriteLine("Rotor: ", ((Hubschrauber)lfzg).RotorDurchmesser);
    else
      Console.WriteLine("Unbekannter Typ.");
  }
}

In der Methode wird der Parameter lfzg drei Überprüfungen unterzogen. Dabei steht links vom is-Operator die zu überprüfende Referenz, rechts davon der Typ, auf den hin die Referenz geprüft werden soll. Der Vergleich liefert true, wenn der Ausdruck, also die Referenz, in den rechts von is stehenden Typ umgewandelt werden kann.

Da der Methodenaufruf auch dann richtig ist, wenn dem Parameter null übergeben wird, sollte der Parameter als Erstes mit


if (lfzg != null)

daraufhin untersucht werden, ob er auch tatsächlich ein konkretes Objekt beschreibt.

Beachten Sie im Codefragment auch die Konsolenausgabe, zum Beispiel:


((Flugzeug)lfzg).Spannweite

Der Ausdruck (Flugzeug)lfzg wurde in runde Klammern gesetzt, um eine Typkonvertierung vor dem Aufruf der Eigenschaft zu erzwingen. Der Grund dafür ist, dass der Punktoperator eine höhere Priorität besitzt als der Konvertierungsoperator. Nach der zusätzlichen Klammerung bezieht der Punktoperator dann seine Informationen aus dem Zieldatentyp der Umwandlung.


Galileo Computing - Zum Seitenanfang

4.3.4 Typumwandlung mit dem as-Operator topZur vorigen Überschrift

Eine Referenz kann mit dem ()-Konvertierungsoperator in einen anderen Typ konvertiert werden, wenn vorher eine implizite Konvertierung stattgefunden hat. Beispielsweise kann eine Instanz der Klasse Luftfahrzeug in den Typ Flugzeug konvertiert werden:


Flugzeug flg = (Flugzeug)lfzg;

C# bietet mit dem as-Operator noch eine weitere Konvertierungsvariante an:


Flugzeug flg = lfzg as Flugzeug;

Das Ergebnis ist dasselbe – wenn sich hinter der Referenz lfzg auch tatsächlich eine Flugzeug-Referenz verbirgt. Beide Möglichkeiten, also der Konvertierungs- und der as-Operator, verhalten sich aber unterschiedlich, wenn die Basisklassenreferenz keine Flugzeug-, sondern beispielsweise eine Hubschrauber-Referenz beschreibt:

  • Die Typumwandlung mit dem Konvertierungsoperator löst eine Exception (Ausnahme) aus, wenn die Konvertierung scheitert.
  • Der as-Operator liefert als Ergebnis null.

Der as-Operator bietet sich daher auch in einem if-Statement als Bedingung an:


if(lfzg as Flugzeug != null)
  ...

Beachten Sie, dass der as-Operator nur im Zusammenhang mit Referenztypen genutzt werden kann.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern