Oops Concepts – Polymorphism

What is Polymorphism ?
In Polymorphism ‘poly’ means ‘many’ and ‘morph’ means ‘forms’ so polymorphism means many forms.

Basically There are two types of Polymorphism

1. Compile Time Polymorphism
2. Run Time Polymorphism

Compile Time Polymorphism 
It is also known as ‘Static Polymorphism’ or ‘Early Binding’ or ‘Method Overloading’.
In Method Overloading or Compile Time polymorphism or Static Polymorphism we create multiple methods with same name but with different signatures.

Run Time Polymorphism 
It is also known as ‘Dynamic Polymorphism’ or ‘Late Binding’ or ‘Method Overriding’.
In Method Overriding or Run Time Polymorphism or Dynamic Polymorphism we create method in base class & we can override same method in derived class using ‘Virtual’ or ‘Override’ keywords.
There are two ways or doing

1. Virtual Functions
2. Abstract Class

Oops c# Concepts – Constructor and Types of Constructor

Description:

• Constructor is special type of method which is automatically invoked when instance/object of class is made.
• If constructor is not defined for class then compiler will automatically create one for that class when creating object/instance of that class.
• Constructors are used for object initialization and memory allocation of its class
• Class can have any number of constructors but we can create only one static constructor in a class.
• Constructors do not have any return types.
• Constructor have same name as that of its class.
  E.g.

  class Abc {
     public Abc(){
         Console.WriteLine("Default Constructor");
     }
  }

Types of Constructor:
There are 5 types of constructors

1. Default Constructor
2. Parameterized Constructor
3. Copy Constructor
4. Static Constructor
5. Private Constructor

Default Constructor

• Default Constructor is constructor without any parameters.
• E.g.

  class Abc {
     public Abc(){
         Console.WriteLine("Default Constructor");
     }
  }
  class Program{
      static void Main(string[] args){
         Abc obj = new Abc(); 
      }
  }

Parameterized Constructor

• Parameterized Constructor is constructor with atleast one patameter.
• E.g.

  class Abc {
     public Abc(int param1){
         Console.WriteLine(param1);
     }
  }
  class Program{
      static void Main(string[] args){
         Abc obj = new Abc(10); 
      }
  }

Copy Constructor

• Copy Constructor is a parameterized constructor having class object type as paramterer
• Purpose of Copy Constructor is to create new instance of class with same values.
• E.g.

  class Abc {
     public int Param1;
     public Abc(int x){
         Param1 = x;
     }
     public Abc(Abc obj){
         Param1 = obj.Param1;
     }
  
  }
  class Program{
      static void Main(string[] args){
         Abc obj = new Abc(10); 
         Abc obj2 = new Abc(obj); 
      }
  }

Static Constructor

• Static Constructor is a constructor which is invoked during creation of first instance of class.
• Static Constructor is used to initialize static fields.
• E.g.

  class Abc {
      static Abc(){
         Console.WriteLine("Static Constructor");
     }
     public Abc(){
         Console.WriteLine("Default Constructor");
     }
  }
  class Program{
      static void Main(string[] args){
         Abc obj = new Abc(); // both static & default constructors are invoked
  Abc obj2 = new Abc(); // only default construcotr is invoked
      }
  }

Private Constructor

• Private constructor is a special instance constructor used in a class that contains static member only
• E.g.

  class Abc {
     public int x;
     private Abc(){
         Console.WriteLine("Private Constructor");
     }
  public Abc(int a){
         x = a;
         Console.WriteLine("Parameterized Constructor");
     }
  }
  class Program{
      static void Main(string[] args){
         Abc obj = new Abc(10); // it will work fine. 
         Abc obj = new Abc();   // it will give error as constructor without parameters is private.
      }
  }