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

Inhaltsverzeichnis
Vorwort zur 6. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Das Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Strukturen und Enumerationen
7 Fehlerbehandlung und Debugging
8 Auflistungsklassen (Collections)
9 Generics – Generische Datentypen
10 Weitere C#-Sprachfeatures
11 LINQ
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 XML
15 Multithreading und die Task Parallel Library (TPL)
16 Einige wichtige .NET-Klassen
17 Projektmanagement und Visual Studio 2012
18 Einführung in die WPF und XAML
19 WPF-Layout-Container
20 Fenster in der WPF
21 WPF-Steuerelemente
22 Elementbindungen
23 Konzepte von WPF
24 Datenbindung
25 Weitere Möglichkeiten der Datenbindung
26 Dependency Properties
27 Ereignisse in der WPF
28 WPF-Commands
29 Benutzerdefinierte Controls
30 2D-Grafik
31 ADO.NET – Verbindungsorientierte Objekte
32 ADO.NET – Das Command-Objekt
33 ADO.NET – Der SqlDataAdapter
34 ADO.NET – Daten im lokalen Speicher
35 ADO.NET – Aktualisieren der Datenbank
36 Stark typisierte DataSets
37 Einführung in das ADO.NET Entity Framework
38 Datenabfragen des Entity Data Models (EDM)
39 Entitätsaktualisierung und Zustandsverwaltung
40 Konflikte behandeln
41 Plain Old CLR Objects (POCOs)
Stichwort

Download:
- Beispiele, ca. 62,4 MB

Buch bestellen
Ihre Meinung?

Spacer
Visual C# 2012 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2012

Visual C# 2012
Rheinwerk Computing
1402 S., 6., aktualisierte und erweiterte Auflage 2013, geb., mit DVD
49,90 Euro, ISBN 978-3-8362-1997-6
Pfeil 4 Vererbung, Polymorphie und Interfaces
Pfeil 4.1 Die Vererbung
Pfeil 4.1.1 Basisklassen und abgeleitete Klassen
Pfeil 4.1.2 Die 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 Die 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 Die implizite Typumwandlung von Objektreferenzen
Pfeil 4.3.2 Die 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 Die »klassische« Methodenimplementierung
Pfeil 4.4.2 Abstrakte Methoden
Pfeil 4.4.3 Virtuelle Methoden
Pfeil 4.5 Weitere Gesichtspunkte der Vererbung
Pfeil 4.5.1 Versiegelte Methoden
Pfeil 4.5.2 Überladen einer Basisklassenmethode
Pfeil 4.5.3 Statische Member und Vererbung
Pfeil 4.5.4 Geerbte Methoden ausblenden?
Pfeil 4.6 Das Projekt »GeometricObjectsSolution« ergänzen
Pfeil 4.6.1 Die Klasse »GeometricObject«
Pfeil 4.7 Eingebettete Klassen (Nested Classes)
Pfeil 4.8 Interfaces (Schnittstellen)
Pfeil 4.8.1 Einführung in die Schnittstellen
Pfeil 4.8.2 Die Schnittstellendefinition
Pfeil 4.8.3 Die Schnittstellenimplementierung
Pfeil 4.8.4 Die Interpretation der Schnittstellen
Pfeil 4.8.5 Änderungen am Projekt »GeometricObjects«
Pfeil 4.9 Das Zerstören von Objekten – der »Garbage Collector«
Pfeil 4.9.1 Die Arbeitsweise des Garbage Collectors
Pfeil 4.9.2 Expliziter Aufruf des Garbage Collectors
Pfeil 4.9.3 Der Destruktor
Pfeil 4.9.4 Die »IDisposable«-Schnittstelle
Pfeil 4.9.5 Die Ergänzungen in den Klassen »Circle« und »Rectangle«

Galileo Computing - Zum Seitenanfang

4.3 Typumwandlung und Typuntersuchung von ObjektvariablenZur nächsten Überschrift


Galileo Computing - Zum Seitenanfang

4.3.1 Die implizite Typumwandlung von ObjektreferenzenZur nächsten ÜberschriftZur vorigen Überschrift

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

Betrachten wir einen Ausschnitt der Klassenhierarchie, nämlich die beiden Klassen Flugzeug und Luftfahrzeug. Wenn wir unsere Erkenntnisse aus der realen Welt auf unseren Code projizieren, kommen wir zu der Aussage, dass ein Flugzeug ein Luftfahrzeug ist. Andererseits ist aber ein Luftfahrzeug nicht zwangsläufig ein Flugzeug, denn es könnte sich auch um einen Hubschrauber handeln. Die Tatsache, dass das Objekt einer abgeleiteten Klasse (hier Flugzeug) 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, denn aufgrund dieser Beziehung kann man die Referenz eines Subklassenobjekts einer Basisklassenreferenz zuweisen:

Flugzeug flg = new Flugzeug();
Luftfahrzeug lfzg = flg;

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 flg und lfzg referenzieren denselben Speicherbereich – jedoch mit einer kleinen Einschränkung: Die Laufzeitumgebung betrachtet lfzg nur als Objekt vom Typ Luftfahrzeug und nicht als Flugzeug. Damit hat die Objektreferenz lfzg auch keinen Zugriff auf die Member, durch die sich ein Objekt vom Typ Flugzeug 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 rechts vom Zuweisungsoperator stehenden Referenz haben. Betrachten Sie dazu die Abbildung 4.5, die diesen Sachverhalt veranschaulicht. Dass dabei das Feld Spannweite einer Flugzeug-Referenz keinen Abnehmer in der Luftfahrzeug-Referenz findet, spielt keine Rolle.

Abbildung

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 DoSomething(Luftfahrzeug lfzg) {
[...]
}

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

Flugzeug flg = new Flugzeug();
@object.DoSomething(flg);

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

public void DoSomething(Luftfahrzeug lfzg) {
[...]
lfzg.Starten();
[...]
}

Da sowohl ein Flugzeug- als auch ein Hubschrauber-Objekt über diese Methode verfügt, ist DoSomething eine hinsichtlich der Luftfahrzeuge allgemein gehaltene Methode. Das erspart Ihnen, zwei verschiedene Methoden DoSomething 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 DoSomething bei einer späteren Erweiterung der Vererbungshierarchie, beispielsweise durch eine Klasse Rocket, auch mit einem Objekt vom Typ Rocket einwandfrei funktioniert.


Galileo Computing - Zum Seitenanfang

4.3.2 Die explizite Typumwandlung von ObjektreferenzenZur nächsten ÜberschriftZur vorigen Überschrift

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

Flugzeug flg = new Flugzeug();
Luftfahrzeug lfzg = flg;
[...]
Flugzeug flugzeug = (Flugzeug)lfzg;

Listing 4.13 Explizite Typkonvertierung

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 Ausgangs- und Zieldatentyp in einer Vererbungsbeziehung befinden.

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


Galileo Computing - Zum Seitenanfang

4.3.3 Typuntersuchung mit dem »is«-OperatorZur nächsten ÜberschriftZur vorigen Überschrift

Manchmal ist es notwendig, den sich hinter einer Basisklassenreferenz verbergenden Typ festzustellen, beispielsweise wenn ein typspezifischer 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 DoSomething soll in Abhängigkeit vom übergebenen Typ entweder die Spannweite oder der Rotordurchmesser ausgegeben werden. Wir müssen dann die Methode wie nachfolgend gezeigt ergänzen:

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

Listing 4.14 Typuntersuchung mit dem Operator »is«

In der Methode wird der Parameter lfzg zwei Ü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, z. B.:

((Flugzeug)lfzg).Spannweite

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


Galileo Computing - Zum Seitenanfang

4.3.4 Typumwandlung mit dem »as«-OperatorZur 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, 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# 2012

Visual C# 2012
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 2013
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.


[Rheinwerk Computing]

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