Topic : Inheritance In C# Programming Language. |"Base" Keyword:|



WHAT IS INHERITANCE?

Inheritance is where Object-Oriented Programming really comes into its own. Understanding this most important concept is the key to effective C# Programming and the goal of this Tutorial. There's no going back now. after you've completed this part, you can call yourself an Object-Oriented-Programmer. so to understand the concept of Inheritance, let's take a real-life example in our this tutorial.



image: real example of inheritance

Inheritance is why we look similar to our Mom or Dad. People's bodies have characteristics, like the shape of their nose or the color of their eyes, and parents pass on these characteristics to their children, this is inheritance.

We are made of cells like a building is made of bricks. Our cells are told what to do by DNA. DNA is the boss and tells the cells how to make a human body. All of us are made up of DNA from both our Mom and dads so we inherit orders on how to build a body from both of them that is why we have characteristics from both our parents.

People look like People. Every Person is Unique but they have far more in common than they are different. This is Because we all are related and we have all inherited characteristics from our ancestors. This is all Inheritance. and Now I can hope that you Understand the concept of Inheritance, So Let's move to our Programming World.



inheritance in C#:

Inheritance is one of the most Important concepts in OOP. Inheritance Allows us to define a Class in terms of Another Class, which makes it easier to create and Maintain an application. This Also Provides an Opportunity to reuse the code functionality and speeds up implementation time.

When We create a Class, Instead of Writing completely New Data Members and Member Methods, we can Designate that the New class should inherit the Members of an Existing Class. This Existing Class is called the Base Class, and the New class is referred to as the Derived Class.



In C#, The class which Inherits the Members of another class is Called Derived Class and the Class whose Members are Inherited is Called Base Class


Syntax:

A Class can be derived from More than One Class. Which Means that it can Inherit data and Methods from Multiple base classes. We can create an Derived Class using the Following Syntax:


     Access-Specifier    class     Base_Class 
{
    // Base Class Body:
}


class   Derived_Class   : Base_class
{
    // Derived Class Body:
}


  • In Above Syntax:

    » Access-Specifier Defines the Scope and Visibility of a Class.
    » Class is The Keyword to Define Class.
    » Base_Class is the name of Class whose members will be inherited by Derived Class.
    » Derived_Class is the the name of Class Which will Inherit the Members of Base_Class
    » : colon " : " is the Special Character to make a Relationship between the Base and Derived Class.



Let's have a Simple example to Know, How this Inheritance Work. We will create two classes, and the second class will use some Methods and Members of first class sense of Inheritance.


/*Example: Inheritance : InfoBrother: */

using System;

namespace Inheritance
{
    class base_class    //base Class:
    {
        public double width;
        public double height;

        public void show()
        {
            Console.WriteLine("Width = {0} | Height = {1}", width, height);
        }
    }



    class derived_class : base_class //Derived Class:
    {
        public string style;
        public double area()
        {
            return width * height / 2; //using Base Class Members:
        }

        public void showStyle()
        {
            Console.WriteLine("Triangle is: " + style);
        }
    }



    class Program   //main class.
    {
        static void Main(string[] args)
        {
            //creating object of type Derived_class:
            derived_class tringle1 = new derived_class();
            derived_class tringle2 = new derived_class();

            //setting Values for Triangle 1.
            tringle1.width = 4.0;
            tringle1.height = 4.0;
            tringle1.style = "Isosceles";

            //show Triangle 1.
            Console.WriteLine("Triangle 1: ");
            tringle1.show();
            tringle1.showStyle();


            //setting Values for Triangle 2.
            tringle2.width = 8.0;
            tringle2.height = 12.0;
            tringle2.style = "Right";
                       
            //Show Triangle 2.
            Console.WriteLine("\nTriangle 2: ");
            tringle2.show();
            tringle2.showStyle();

            Console.ReadKey();
        }
    }
}


In Above Example, We create Two Classes: a Base Class and Derived Class. The Base Class define the Attributes of two-dimensional shape such as Square, Rectangle, and Triangle, and so on. the derived class inherit the Properties of Base class and create a two-dimensional shape that is Triangle. this is very simple and conceptual example to understand the concept of Inheritance.



image: Inheritance, Base and Derive Class.

Member Access and Inheritance:

A Derived Class can access all the non-private members of its base class. Thus base-class members that should not be accessible to the member function of derived classes should be declared private in the base class. We can summarize the different access types according to who can access them, in the following way:



AccessPublicProtectedPrivate
Same Class YesYesYes
Derived ClassYesYesNo
Outside ClassYesNoNo


Base Keyword:

The Base Keyword is Used when we want to access members and methods of the base class, from within a derived class. This keyword serves two essential purposes.
» This keyword call a method on the base class that has been overridden by another method.
» Specify which base class constructor should be called when creating instance of the derived class.

Let's have an Example to understand the concept of base keyword. In this Example, we will create two classes and the both classes will use the same method website() . and by using the keyword base it is possible to call the website() method in the base class from within the derived class.



/*Example: Inheritance - base keyword- : InfoBrother: */

using System;

namespace Inheritance
{
    class base_class    //base Class:
    {
        protected string web = "www.";
        protected string name = "InfoBrother";
        protected string domain = ".com";

        public virtual void website() //virtual Method: 
        {
            Console.WriteLine(web + name + domain);
        }       
    }


    class derived_class : base_class //Derived Class:
    {
        public override void website() //overridden method:
        {
            Console.WriteLine("for More Information visit-");
            base.website();  //calling method Using "base" Keyword:
        }
    }



    class Program   //main class.
    {
        static void Main(string[] args)
        {
            derived_class obj = new derived_class(); //object:
            obj.website();   //method calling:

            Console.ReadKey();
        }
    }
}


  • Advantages of Inheritance:

    If we Develop Any Application using the concept of Inheritance, The Application will have the Following Advantages:
    » Development of Application will take less time.
    » Application will assume less Memory.
    » Execution time of Application will be less.
    » Enhance Application Performance.
    » Repetition of the code will reduce so that we get consistence results and less storage cost.



















I Tried my Best to Provide you complete Information regarding this topic in very easy and conceptual way. but still if you have any Problem to understand this topic, or do you have any Questions, Feel Free to Ask Question. i'll do my best to Provide you what you need.

Sardar Omar.
InfoBrother





Advertising

Advertisement