Diving in OOP (Part 1) : Polymorphism and Inheritance(Early Binding/Compile Time Polymorphism).

Introduction

OOPS

1. What is OOPS and what is advantage of OOP?

2. What are OOP Concepts?

1. Data Abstraction: Data Abstraction is a concept in which the internal and superfluous details of the implementation of a logic is hidden from an end user(who is using the program) .A user can use any of the data and method from the class without knowing about how this is created or what is the complexity behind it. In terms of a real world example, when we drive a bike and change the gears we don’t have to care about how internally its working, like how liver is pulled or how chain is set.
2. Inheritance: Inheritance is most popular Concept in OOP’s .This provides a developer an advantage called reusability of code. Suppose a class is written having functions with specific logic, then we can derive that class into our newly created class and we don’t have to write the logic again for derived class functions, we can use them as it is.
3. Data Encapsulation: Wrapping up of member data and member functions of a class in a single unit is called encapsulation. The visibility of the member functions,data members is set via access modifiers used in class.
4. Polymorphism: Poly means many and morphism means many function The Concepts Introduces in the form of Many behaviours of an object.
5. Message Communication: Message Communication means when an object passes the call to method of class for execution.

1. Diving in OOP (Day 1): Polymorphism and Inheritance(Early Binding/Compile Time Polymorphism)
2. Diving in OOP (Day 2): Polymorphism and Inheritance (Inheritance)
3. Diving in OOP (Day 3): Polymorphism and Inheritance (Dynamic Binding/Run Time Polymorphism)
4. Diving in OOP (Day 4): Polymorphism and Inheritance (All about Abstarct classes in C#)
5. Diving in OOP (Day 5): All about access modifiers in C# (Public/Private/Protected/Internal/Sealed/Constants/Readonly Fields)
6. Diving in OOP (Day 6): Understanding Enum in C# (A Practical Approach)
7. Diving into OOP (Day 7): Properties in C# (A Practical Approach)
8. Diving into OOP (Day 8): Indexers in C# (A Practical Approach)
9. Diving into OOP (Day 9): Understanding Events in C# (An Insight)

3. Polymorphism:

Method Overloading or Early Binding or Compile Time Polymorphism

1. Let’s create a simple console application named InheritanceAndPolymorphism, and add a class namedOverload.cs and add three methods named DisplayOverload having varied parameters as follows,
   

   Overload.cs

    Collapse | Copy Code

   public class Overload
       {
           public void DisplayOverload(int a){
               System.Console.WriteLine("DisplayOverload " + a);
           }
           public void DisplayOverload(string a){
               System.Console.WriteLine("DisplayOverload " + a);
           }
           public void DisplayOverload(string a, int b){
               System.Console.WriteLine("DisplayOverload " + a + b);
           }
       }

   In the main method in Program.cs file, add the following code,

   Program.cs

    Collapse | Copy Code

   class Program
       {
           static void Main(string[] args)
           {
               Overload overload = new Overload();
               overload.DisplayOverload(100);
               overload.DisplayOverload("method overloading");
               overload.DisplayOverload("method overloading", 100);
               Console.ReadKey();
           }
       }

Output

 Collapse | Copy Code

public void DisplayOverload() { }
     public int DisplayOverload(){ }

 Collapse | Copy Code

static void DisplayOverload(int a)  {   }
public void DisplayOverload(int a) {   }
public void DisplayOverload(string a){  }

 Collapse | Copy Code

private void DisplayOverload(int a) {   }

private void DisplayOverload(out int a)
{
a = 100;
}

private void DisplayOverload(ref int a) { }

4. Role of Params Parameter in Polymorphism

1. pass by value,
2. Pass by reference,
3. As an output parameter,
4. Using parameter arrays.

 Collapse | Copy Code

public void DisplayOverload(int a, string a)  {   }

public void Display(int a)
{
string a;
}

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        private string name = "Akhil";

public void Display()
{
Display2(ref name, ref name);
System.Console.WriteLine(name);
}

private void Display2(ref string x, ref string y)
{
System.Console.WriteLine(name);
x = “Akhil 1″;
System.Console.WriteLine(name);
y = “Akhil 2″;
System.Console.WriteLine(name);
name = “Akhil 3″;
}
}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            DisplayOverload(100, "Akhil", "Mittal", "OOP");
            DisplayOverload(200, "Akhil");
            DisplayOverload(300);
        }

private void DisplayOverload(int a, params string[] parameterArray)
{
foreach (string str in parameterArray)
Console.WriteLine(str + “ “ + a);
}
}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

 Collapse | Copy Code

private void DisplayOverload(int a, params string[] parameterArray, int b) {  }

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            DisplayOverload(100, 200, 300);
            DisplayOverload(200, 100);
            DisplayOverload(200);
        }

private void DisplayOverload(int a, params int[] parameterArray)
{
foreach (var i in parameterArray)
Console.WriteLine(i + “ “ + a);
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

 Collapse | Copy Code

private void DisplayOverload(int a, params string[][] parameterArray)  {     }

private void DisplayOverload(int a, params string[,] parameterArray) { }

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            string[] names = {"Akhil", "Ekta", "Arsh"};
            DisplayOverload(3, names);
        }

private void DisplayOverload(int a, params string[] parameterArray)
{
foreach (var s in parameterArray)
Console.WriteLine(s + “ “ + a);
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
           string [] names = {"Akhil","Arsh"};
           DisplayOverload(2, names, "Ekta");
        }

private void DisplayOverload(int a, params string[] parameterArray)
{
foreach (var str in parameterArray)
Console.WriteLine(str + “ “ + a);
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

So, we got two errors. 

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            int[] numbers = {10, 20, 30};
            DisplayOverload(40, numbers);
            Console.WriteLine(numbers[1]);
        }

private void DisplayOverload(int a, params int[] parameterArray)
{
parameterArray[1] = 1000;
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            int number = 102;
            DisplayOverload(200, 1000, number, 200);
            Console.WriteLine(number);
        }

private void DisplayOverload(int a, params int[] parameterArray)
{
parameterArray[1] = 3000;
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public void Display()
        {
            DisplayOverload(200);
            DisplayOverload(200, 300);
            DisplayOverload(200, 300, 500, 600);
        }

private void DisplayOverload(int x, int y)
{
Console.WriteLine(“The two integers “ + x + “ “ + y);
}

private void DisplayOverload(params int[] parameterArray)
{
Console.WriteLine(“parameterArray”);
}

}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            Overload overload = new Overload();
            overload.Display();
            Console.ReadKey();
        }
    }

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public static void Display(params object[] objectParamArray)
        {
            foreach (object obj in objectParamArray)
            {
                Console.Write(obj.GetType().FullName + " ");
            }
            Console.WriteLine();

}
}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            object[] objArray = { 100, "Akhil", 200.300 };
            object obj = objArray;
            Overload.Display(objArray);
            Overload.Display((object)objArray);
            Overload.Display(obj);
            Overload.Display((object[])obj);
            Console.ReadKey();

}
}

Output

Overload.cs

 Collapse | Copy Code

public class Overload
    {
        public static void Display(params object[] objectParamArray)
        {
            Console.WriteLine(objectParamArray.GetType().FullName);
            Console.WriteLine(objectParamArray.Length);
            Console.WriteLine(objectParamArray[0]);

}
}

Program.cs

 Collapse | Copy Code

class Program
    {
        static void Main(string[] args)
        {
            object[] objArray = { 100, "Akhil", 200.300 };
            Overload.Display((object)objArray);
            Console.ReadKey();
        }
    }

Output

5. Conclusion

1. C# recognizes the method by its parameters and not by its name.
2. The return value/parameter type of a method is never the part of method signature if the names of the methods are same. So this is not polymorphism.
3. Modifiers such as static are not considered as part of method signature.
4. The signature of a method consists of its name, number and types of its formal parameters. The return type of a function is not part of the signature. Two methods can not have the same signature and also non-members cannot have the same name as members.
5. Parameter names should be unique. And also we can not have a parameter name and a declared variable name in the same function as same.
6. In case of pass by value, the value of the variable is passed and in the case of ref and out, the address of the reference is passed.
7. This params keyword can only be applied to the last argument of the method.So the n number of parameters can only be at the end.
8. C# is very smart to recognize if the penultimate argument and the params have the same data type.
9. Parameter array must be a single dimensional array.

In upcoming articles we’ll cover topics in the same fashion.  Happy Coding.

Read more:

• C# and ASP.NET Questions (All in one)
• MVC Interview Questions
• C# and ASP.NET Interview Questions and Answers
• Web Services and Windows Services Interview Questions

Other Series

My other series of articles:

• Learning MVC
• Learning WebAPIs in .Net

For more informative articles visit my Blog.