In today's world, inheritance is usually associated with the end of things. In OOP, however, it is associated with the beginning of something new and better. When we create a new class, we can take an already existing class and have our new class inherit from it. This means that our new object will have all the features of the inherited class, as well as the additional features added to the new class. This is at the root of inheritance. We call a class that inherits from another a derived class.
To illustrate the concept of inheritance, we will create a few classes that inherit from another to form new, more feature-rich objects.
- Create a new class library by right-clicking on your solution and selecting Add and then New Project from the context menu:
- From the Add New Project dialog screen, select Class Library from the installed templates and call your class
Chapter3:
- Your new class library will be added to your solution with a default name
Class1.cs, which we renamed toRecipes.csin order to distinguish the code properly. You can, however, rename your class to whatever you like if it makes more sense to you. - To rename your class, simply click on the class name in the Solution Explorer and select Rename from the context menu:
- Visual Studio will ask you to confirm the renaming of all references to the code element Class1 in the project. Just click on Yes:
- Now, let's create a new class called
SpaceShip:public class SpaceShip { } - Our
SpaceShipclass will contain a few methods that describe the basics of a spaceship. Go ahead and add these methods to yourSpaceShipclass:public class SpaceShip { public void ControlBridge() { } public void MedicalBay(int patientCapacity) { } public void EngineRoom(int warpDrives) { } public void CrewQuarters(int crewCapacity) { } public void TeleportationRoom() { } }Because the
SpaceShipclass forms part of all other intergalactic vessels, it becomes the blueprint for every other vessel. - Next, we want to create a
Destroyerclass. To accomplish this, we will create aDestroyerclass and use a colon after the class name to indicate that we want to inherit from another class (theSpaceShipclass). Therefore, the following needs to be added when creating theDestroyerclass:public class Destroyer : SpaceShip { } - Next, add a few methods to the
Destroyerclass that are unique to a destroyer. These methods belong only to theDestroyerclass and not to theSpaceShipclass:public class Destroyer : SpaceShip { public void WarRoom() { } public void Armory(int payloadCapacity) { } public void WarSpecialists(int activeBattalions) { } } - Finally, create a third class called
Annihilator. This is the most powerful intergalactic vessel and is used to wage war on planets. Let theAnnihilatorclass inherit from theDestroyerclass by creating the class and marking it as derived from theDestroyerclass as followsAnnihilator : Destroyer:public class Annihilator : Destroyer { } - Finally, add a few methods to the
Annihilatorclass that only belong to this type ofSpaceShipclass:public class Annihilator : Destroyer { public void TractorBeam() { } public void PlanetDestructionCapability() { } } - Inside the console application, add a reference to the
Chapter3class library by right-clicking on References under the CodeSamples project and selecting Add Reference from the context menu:
- In the Reference Manager window, select the
Chapter3solution under Projects | Solutions. This will allow you to use the classes we just created in your console application:
- What we see now is that when we create a new instance of the
SpaceShipclass, only the methods defined in that class are available to us. This is because theSpaceShipclass does not inherit from any other class:
- Go ahead and create the
SpaceShipclass with its methods in the console application:SpaceShip transporter = new SpaceShip(); transporter.ControlBridge(); transporter.CrewQuarters(1500); transporter.EngineRoom(2); transporter.MedicalBay(350); transporter.TeleportationRoom();
You will see that these are the only methods available to us when instantiating a new instance of this class.
- Next, create a new instance of the
Destroyerclass. You will notice that theDestroyerclass contains more methods than what we defined when we created the class. This is because theDestroyerclass is inheriting theSpaceShipclass and therefore inherits the methods of theSpaceShipclass:
- Go ahead and create the
Destroyerclass with all its methods in the console application:Destroyer warShip = new Destroyer(); warShip.Armory(6); warShip.ControlBridge(); warShip.CrewQuarters(2200); warShip.EngineRoom(4); warShip.MedicalBay(800); warShip.TeleportationRoom(); warShip.WarRoom(); warShip.WarSpecialists(1);
- Finally, create a new instance of the
Annihilatorclass. This class contains all the methods of theDestroyerclass as well as the methods from theSpaceShipclass. This is becauseAnnihilatorinherits fromDestroyer, which, in turn, inherits fromSpaceShip:
- Go ahead and create the
Annihilatorclass with all its methods in the console application:Annihilator planetClassDestroyer = new Annihilator(); planetClassDestroyer.Armory(12); planetClassDestroyer.ControlBridge(); planetClassDestroyer.CrewQuarters(4500); planetClassDestroyer.EngineRoom(7); planetClassDestroyer.MedicalBay(3500); planetClassDestroyer.PlanetDestructionCapability(); planetClassDestroyer.TeleportationRoom(); planetClassDestroyer.TractorBeam(); planetClassDestroyer.WarRoom(); planetClassDestroyer.WarSpecialists(3);
We can see that inheritance allowed us to easily extend our classes by reusing functionality that already exists within another class created earlier. You also need to be aware though that any changes to the SpaceShip class will be inherited up the stack to the top-most derived class.
Inheritance is a very powerful feature of C#, which allows developers to write less code and reuse working and tested methods.