218 Part II Understanding the C# Language
unique to that type of mammal, such as Trot (for a horse) or Swim (for a whale) in its own way. How would you handle methods that are common to a horse and a whale, such as Breathe or SuckleYoung? You could add duplicate methods with these names to both classes, but this
situation becomes a maintenance nightmare, especially if you also decide to start modeling other types of mammal, such as Human or Aardvark.
In C#, you can use class inheritance to address these issues. A horse, a whale, a human, and an aardvark are all types of mammal, so create a class named Mammal that provides the
common functionality exhibited by these types. You can then declare that the Horse, Whale, Human, and Aardvark classes all inherit from Mammal. These classes would then automatically provide the functionality of the Mammal class (Breathe, SuckleYoung, and so on), but you
could also add the functionality peculiar to a particular type of mammal to the corresponding class—the Trot method for the Horse class and the Swim method for the Whale class. If you need to modify the way in which a common method such as Breathe works, you need to change it in only one place, the Mammal class.
Using Inheritance
This section covers the essential inheritance-related syntax that you need to understand in order to create classes that inherit from other classes in C#.
Base Classes and Derived Classes
The syntax for declaring a class that inherits from another class is as follows:
class DerivedClass : BaseClass {
...
}
The derived class inherits from the base class, and the methods in the base class also become
part of the derived class. In C#, a class is allowed to derive from, at most, one other class; a class is not allowed to derive from two or more classes. However, unless DerivedClass is declared as sealed, you can create further derived classes that inherit from DerivedClass using
the same syntax. (You will learn about sealed classes in Chapter 13, “Creating Interfaces and Defining Abstract Classes.”)
class DerivedSubClass : DerivedClass {
...
}
Important You cannot use inheritance with structures. A structure cannot inherit from a class or another structure.
Chapter 12 Working with Inheritance |
219 |
In the example described earlier, you could declare the Mammal class as shown here. The methods Breathe and SuckleYoung are common to all mammals.
class Mammal
{
public void Breathe()
{
...
}
public void SuckleYoung()
{
...
}
...
}
You could then define classes for each different type of mammal, adding additional methods as necessary. For example:
class Horse : Mammal
{
...
public void Trot()
{
...
}
}
class Horse : Whale
{
...
public void Swim()
{
...
}
}
Note C++ programmers should notice that you do not and cannot explicitly specify whether
the inheritance is public, private, or protected. C# inheritance is always implicitly public. Java programmers should note the use of the colon and that there is no extends keyword.
Remember that the System.Object class is the root class of all classes. All classes implicitly derive from the System.Object class. Consequently, the C# compiler silently rewrites the Mammal class as the following code (which you can write explicitly if you really want to):
class Mammal : System.Object
{
...
}
220 |
Part II Understanding the C# Language |
|
Any methods in the System.Object class are automatically passed down the chain of |
|
inheritance to classes that derive from Mammal, such as Horse and Whale. What this means |
|
in practical terms is that all classes that you define automatically inherit all the features of |
|
the System.Object class. This includes methods such as ToString (first discussed in Chapter 2, |
|
“Working with Variables, Operators, and Expressions”), which is used to convert an object to a |
|
string, typically for display purposes. |
Calling Base Class Constructors
A derived class automatically contains all fields from the base class. These fields usually require initialization when an object is created. You usually perform this kind of initialization in a constructor. Remember that all classes have at least one constructor. (If you don’t provide one, the compiler generates a default constructor for you.) It is good practice for a constructor in a derived class to call the constructor for its base class as part of the initialization. You can specify the base keyword to call a base class constructor when you define a constructor for an inheriting class, as shown in this example:
class Mammal // base class
{
public Mammal(string name) // constructor for base class
{
...
}
...
}
class Horse : Mammal // derived class
{
public Horse(string name)
: base(name) // calls Mammal(name)
{
...
}
...
}
If you don’t explicitly call a base class constructor in a derived class constructor, the compiler attempts to silently insert a call to the base class’s default constructor before executing the code in the derived class constructor. Taking the earlier example, the compiler will rewrite this:
class Horse : Mammal
{
public Horse(string name)
{
...
}
...
}
Chapter 12 Working with Inheritance |
221 |
As this:
class Horse : Mammal
{
public Horse(string name) : base()
{
...
}
...
}
This works if Mammal has a public default constructor. However, not all classes have a public default constructor (Mammal doesn’t!), in which case forgetting to call the correct base class
constructor results in a compile-time error.
Assigning Classes
In previous examples in this book, you have seen how to declare a variable by using a class type and then how to use the new keyword to create an object. You have also seen how the
type-checking rules of C# prevent you from assigning an object of one type to a variable declared as a different type. For example, given the definitions of the Mammal, Horse, and
Whale classes shown here, the code that follows these definitions is illegal:
class Mammal
{
...
}
class Horse : Mammal
{
...
} |
|
class Whale : Mammal |
|
{ |
|
... |
|
} |
|
... |
// constructor shown earlier expects a name! |
Horse myHorse = new Horse(“Neddy”); |
|
Whale myWhale = myHorse; |
// error – different types |
However, it is possible to refer to an object from a variable of a different type as long as the type used is a class that is higher up the inheritance hierarchy. So the following statements are legal:
Horse myHorse = new Horse(“Neddy”);
Mammal myMammal = myHorse; // legal, Mammal is the base class of Horse
If you think about it in logical terms, all Horses are Mammals, so you can safely assign an object of type Horse to a variable of type Mammal. The inheritance hierarchy means that you