Chapter 58: Inheritance

Section 58.1: Inheritance. Constructors' calls sequence

Consider we have a class Animal which has a child class Dog

class Animal

{

public Animal()

{

Console.WriteLine("In Animal's constructor");

}

}

class Dog : Animal

{

public Dog()

{

Console.WriteLine("In Dog's constructor");

}

}

By default every class implicitly inherits the Object class.

This is same as the above code.

class Animal : Object

{

public Animal()

{

Console.WriteLine("In Animal's constructor");

}

}

When creating an instance of Dog class, the base classes's default constructor (without parameters) will be called if there is no explicit call to another constructor in the parent class. In our case, first will be called

Object's constructor, then Animal's and at the end Dog's constructor.

public class Program

{

public static void Main()

{

Dog dog = new Dog();

}

}

Output will be

In Animal's constructor

In Dog's constructor

View Demo

Call parent's constructor explicitly.

In the above examples, our Dog class constructor calls the default constructor of the Animal class. If you want, you can specify which constructor should be called: it is possible to call any constructor which is defined in the parent class.

Consider we have these two classes.

class Animal

{

protected string name;

public Animal()

{

Console.WriteLine("Animal's default constructor");

}

public Animal(string name)

{

this.name = name;

Console.WriteLine("Animal's constructor with 1 parameter"); Console.WriteLine(this.name);

}

}

class Dog : Animal

{

public Dog() : base()

{

Console.WriteLine("Dog's default constructor");

}

public Dog(string name) : base(name)

{

Console.WriteLine("Dog's constructor with 1 parameter"); Console.WriteLine(this.name);

}

}

What is going here?

We have 2 constructors in each class.

What does base mean?

base is a reference to the parent class. In our case, when we create an instance of Dog class like this

Dog dog = new Dog();

The runtime first calls the Dog(), which is the parameterless constructor. But its body doesn't work immediately. After the parentheses of the constructor we have a such call: base(), which means that when we call the default Dog constructor, it will in turn call the parent's default constructor. After the parent's constructor runs, it will return and then, finally, run the Dog() constructor body.

So output will be like this:

Animal's default constructor

Dog's default constructor

public class Cat : Animal

{

public Cat()

{

Name = "Cat";

}

// Methods for scratching furniture and ignoring owner public void Scratch(Object furniture)

{

// ...

}

}

The Cat class gets access to not only the methods described in its definition explicitly, but also all the methods defined in the general Animal base class. Any Animal (whether or not it was a Cat) could Eat, Stare, or Roll. An Animal would not be able to Scratch, however, unless it was also a Cat. You could then define other classes describing other animals. (Such as Gopher with a method for destroying flower gardens and Sloth with no extra methods at all.)

Section 58.3: Inheriting from a class and implementing an interface

public class Animal

{

public string Name { get; set; }

}

public interface INoiseMaker

{

string MakeNoise();

}

//Note that in C#, the base class name must come before the interface names public class Cat : Animal, INoiseMaker

{

public Cat()

{

Name = "Cat";

}

public string MakeNoise()

{

return "Nyan";

}

}

Section 58.4: Inheriting from a class and implementing multiple interfaces

public class LivingBeing

{

string Name { get; set; }

}

public interface IAnimal

{

bool HasHair { get; set; }

}