Home	»	C#	»	Inheritance

Inheritance means using the Pre-defined Code. This is very Main Feature of OOP With the advantage of Inheritance we can use any code that is previously created With the help of inheritance we uses the code that is previously Defined but always Remember We are only using that code but not Changing that code With the Advent of inheritance we able to use pre-defined code and also able to add new code. All the pre-defined code is reside into the form of classes if we wants to use that code then we have to inherit or extend that class The Class that is Pre-defined is called as Base or super Class and the class which uses that code is called as derived or sub class There many types of Inheritance provided by C# But Multiple Inheritance is not Provided by C#. Various types of inheritance provided by C# is as follows:

Hiding through Inheritance

Name hiding through inheritance occurs when classes or structs redeclare names that were inherited from base classes. The type of name hiding takes one of the following forms.

A constant, field, property, event, or type introduced in a class or struct hides all base class members with the same name.
A method introduced in a class or struct hides all non-method base class members with the same name, and all base class methods with the same signature.
An indexer introuced in a class or struct hides all base class indexers with the same signature (parameter count and types).

Contrary to hiding a name from an outer scope, hiding an accessible name from an inherited scope causes a warning to be reported. In the example

/* Hiding through Inheritance */
using System;
class a
{
  public void show()
  {
    Console.WriteLine("Base Class");
  }
}
class b:a
{
  public new void show()
  {
    Console.WriteLine("Derived Method");
  }
}

class c
{
  public static void Main()
  {
    b obj = new b();
    obj.show();
  }
}

Output

Inheritance and Constructors

The constructors and destructors are not inherited to a derived class from a Base class. However when we crate an object of the derived class, the derived class constructor implicitly call the base default constructor. The following prgram show this.

/* Inheritance and Constructors */
using System;
class Base
{
  public Base()
  {
    Console.WriteLine("Base Class default Constructor");
  }
}
class Derived:Base
{
  public Derived()
  {
    Console.WriteLine("Derived Class default Constructor");
  }
}

class MyClient
{
  public static void Main()
  {
    Derived obj = new Derived();
  }
}

Output

Containment Class

With the Advent of C# we can Also Develop Also Some Another Form of Inheritance which is also known as the m Containment . Inheritance is Called as Containment when we are Declaring the Object of a class into another Class Then They have a Relationship Like house has a Room and Car has a Stereo etc.

Method Overriding

In inheritance a user may have to face Problem about using the Same name Method in both the Classes like in Base and Derived Classes there is Same Name of a Class so that if we wants to Define a Method which is Similar to base class in a derived Class then we have to use two Keywords as Virtual and Override.

The Method which is declared as Virtual in a base class , can only be Override by derived Class, if in the Derived Class uses Override Keyword along with the Name of Method which we wants to Defined Again. And if you wants to Access the Method of Base Class then we have to use the Base.

Main Method

     The method with the name - Main - with upper case M, has a special significance. It is the entry point in any application. As such there must be at least one Main method in one class of the entire application. When an application is executed it is this method that gets the execution control automatically in the beginning.
Note that more than one class may have Main methods in an application. However, the programmer must specify which Main method is the entry point of application at the compile time failing which the compiler generates error message.

A Main method
public static void Main()
{
  //method body
}

A Main method taking command line arguments and returning no value.
public static void Main(string [] args)
{
  //method body
}

Invoking Methods

     A method, once declared in a class can be invoked (executed) on an object of that class as shown below:

public class abc
{
  public:
    void method1()
    {
    }
}

In this code snippet, a public class - abc - has been declared with a public method - method1 that takes no arguments and returns no value. This method can be invoked on an object of abc type as show below:

abc obj;
obj.method1();

Nesting of Methods

A method is said to be nested, if it invokes other methods from within its definition. Consider the following program for illustration.

/*Nesting of Methods*/
using System;
class NestingMethods
{
  void Largest(int m, int n)
  {
    int l = Max(m,n);     //Nesting
    Console.WriteLine("Largest No = " +l);
  }
  int Max(int a, int b)
  {
    int x = (a > b) ? a : b;
    return (x);
  }
}
class abc
{
  public static void Main()
  {
    NestingMethods obj = new NestingMethods();
    obj.Largest(100,200);    // Method Invoking
  }
}

Output:

Pass By Value

By default all the Methods are declared as value or when no parameter is Specified then all the variables are passed as value to Method Means The Formal Arguments doesn't Affect on the Actual values those are passed for Execution.Consider the following program for illustration.

/*Method Parameters - Pass by Value*/
using System;
class abc
{
  public static void Swap(int x, int y)     //formal
  {
    int t = x;
    x = y;
    y = t;
    Console.WriteLine("X="=x"\n Y="+y);
  }
  public static void Main()
  {
    int a, b;
    a = 12;
    b = 40;
    Swap(a,b);    //actual arguments
    Console.WriteLine("A="+a+ "\n B="+b);
  }
}

Output

Reference Parameters

C# Support provides the concept which is same like pointers means Reference As I Mention when the Arguments are Passed to a Method then the Actual Arguments are not affected But when we wants to Pass Actual Value or when we wants to Change the values of Parameters by formal Arguments then the Arguments Must be Passed by using ref Keyword which also Passes the Address upon Heap where the Actual value of a variable is stored.

/*Pass by Reference*/
using System;
class abc
{
  public static void Swap(ref x, ref y)
  {
    int t = x;
    x = y;
    y = t;
    Console.WriteLine("X="=x"\n Y="+y);
  }
  public static void Main()
  {
    int a, b;
    a = 12;
    b = 40;
    Swap(ref a,ref b);
    Console.WriteLine("A="+a+ "\n B="+b);
  }
}

Output

The Output Parameters

These are Special Parameters and used when we wants to take input as a result which is Produced by another Expression and the Output Parameter When the value of Variable doesn't Specified and the value of variable is depend on the output of another variable . In the variable which we wants to declare as Output then the Corresponding variable of Method also Must have a output Declaration by using out Keyword.
Out keyword is used for return a output not need to declare third variables.

/*Pass by Output parameters*/
using System;
class abc
{
  public static void add(int x, int y, out t)
  {
    t = x + b;
  }
  public static void Main()
  {
    int a, b;
    a = 12;
    b = 40;
    int c;
    add(a,b,out c);
    Console.WriteLine("Sum="+c);
  }
}

Parameter Arrays/Variable Arguement

A parameter declared with a param modifier is a parameter array. If a formal parameter list includes a parameter array, it must be the last parameter in the list and it must be of a single-dimensional array type. For example, the type string[] and string[][] can be used as the type of a parameter array, but the type string[,] can not. It is not possible to combine the params modifier with the ref and out modifiers.

/*Parameter Arrays/Variable Arguement*/
using System;
class Params1
{
  static void Parry(params int[]arr)
  Console.WriteLine("Array Elements are:\n");
    foreach(int i in arr)
    {
      Console.Write(" " + i);
    }
  }
  public static void Main()
  {
    int []x = {11,22,33};
    Parry(x);            //call-1
    Parry();             //call-2
    Parry(100,200); ;  //call-3
  }
}

Output

Param Parameter

As we know that in Method generally the Number of Arguments are fixed for Executing a Method but Some times there is a Situation when we doesn't know about the actual number of Arguments those may have Passed So in that situation the Argument must be declared by using the Params Keyword and any number of Arguments can be Passed to Method either a Zero or More Arguments.
we pass the group of value when we use the param keyword.

/*Param Parameter*/
using System;
class First
{
  public static void Main()
  {
    First objf = new First();
    objf.abc();
  }
  void abc()
  {
    data(2,"M.Sc","IT","RollNo");
    data(4,"3rd");
    data(5);
  }

  static void data(int i, params String[] r)
  {
    foreach(String s in r)
    {
      Console.WriteLine(S + " " + i);
    }
  }
}

Output

Method Overloading

Method Overloading is also called as Function Overloading. Overloading Means a Functions or a Method has many Behaviors. Method Overloading occurred When in class when a functions has same name but different behaviors A Functions said to be overloaded When :-

1) Function has same Name but Different Return Type
2) Difference in Number of Arguments those might be Passed.
3) Difference in Return Type in Arguments.

When We Pass a Call for Execution then it will Match the Criteria of Function Like Number of Arguments and Data types etc The Compiler will finds for a Exact Match and when an Exact Match is Found then the Method will Executed and when a Compiler founds two Functions in a Match then this gives us an error Message.

/*Method Overloading*/
using System;
class MethodOverloading
{
  public static void show(String x)
  {
    Console.WriteLine("X="+x);
  }
  public static void show(int x, int y)
  {
    int c = x + y;
    Console.WriteLine("Sum = "+c);
  }
  public static void Main()
  {
    String n = "Hello C#";
    show(n);
    int a,b;
    a = 200;
    b = 300;
    show(a,b);
  }
}

Output

Method Overriding

When an instance method declaration includes an override modifier, the methods is sait to be an override method.

/*Method Overriding*/
using System;
class Overriding
{
  public virtual void show()
  {
    Console.WriteLine("Hello Java");
  }
}

class abc : overriding
{
  public override void show()
  {
    Console.WriteLine("Hello C#");
  }
}

class MethodOverriding
{
  public static void Main()
  {
    abc obj = new abc();
    obj.show();
  }
}

Output