Abstraction In C#

Abstraction in c#

The word abstract means a concept or an idea not associated with any specific instance.

In C# programming, we apply the same meaning of abstraction by making classes not associated with any specific instance. Abstraction is needed when we only inherit from a certain class but do not need to instantiate objects of that class. In such a case, the base class can be regarded as "Incomplete". Such classes are known as an "Abstract Base Class". 

Abstract Base Class

There are some important points about Abstract Base Class.

1. An Abstract Base class cannot be instantiated; it means the object of that class cannot be created.
2. The class having the abstract keyword with some of its methods (not all) is known as an Abstract Base Class.
3. The class having the Abstract keyword with all its methods is a pure Abstract Base Class.
4. The method of the abstract class that has no implementation is known as "operation". It can be defined as an abstract void method ();
5. An abstract class holds the methods, but the actual implementation is made in the derived class.

Let's have a look at this code!

abstract class animal {    
    public abstract void eat();    
    public void sound() {    
        Console.WriteLine("dog can sound");    
    }    
}  

This is the Abstract Base Class; if I make both methods abstract, it will become a pure Abstract Base Class.

Now, we derive a class of 'dog' from the class animal.

abstract class animal {    
    public abstract void eat();    
    public void sound() {    
        Console.WriteLine("dog can sound");    
    }    
}    
class dog: animal {    
    public override void eat() {    
        Console.WriteLine("dog can eat");    
    }    
}   

Here you can see we have two methods in the Abstract Base Class, the method eat() has no implementation; that is why it is being declared as 'abstract' while the method sound() has its own body, so it is not declared as 'abstract'.

We have the same name method in the derived class, but this method has its body.

We are doing abstraction here so that we can access the method of the derived class without any trouble.

Let's have a look!

class program  
{  
    abstract class animal  
    {  
        public abstract void eat();  
        public void sound()  
        {  
            Console.WriteLine("dog can sound");  
        }  
    }  
    class dog : animal  
    {  
        public override void eat()  
        {  
            Console.WriteLine("dog can eat");  
        }  
    }  
    static void Main(string[] args)  
    {  
        dog mydog = new dog();  
        animal thePet = mydog;  
        thePet.eat();  
        mydog.sound();  
    }  
}  

Finally, we created an Object 'mydog' of class dog but didn't instantiate any object of Abstract Base Class 'animal'.

According to "Ivor Horton" (a programmer of Java), an object can not be instantiated, but we can declare a variable of the Abstract Class type. If this statement is true, then it could be possible:

animal thePet;

This is an object declared as thePet whose data type is the abstract base class 'animal'.

We can use this Object to store Objects of the subclass.

In the above code, we declare an Object, 'thePet', of the type animal (the Abstract Base Class) and copied the object of another object (only the reference is copied as they belong to the reference type). So now we can use object 'thePet' just as object 'mydog'.

The output of this code would be as follows,

  

Conclusion

l conclude here by saying that abstraction is not difficult, but you need to be confident while performing abstraction. Every new topic covers all the previous topics. In abstraction, polymorphism is covered and performed. The method overriding could be done by putting the keyword 'new' before that overridden method. Everything is possible in Programming, and there are multiple ways to do a single job. Abstraction is one of the smart ways to do this kind of task.