Abstract Class & Interface: Two Villains of Every Interview - Part 1

Introduction
Every time I read about a Technical Interview, one question is always out there. What is the difference between an Abstract Class and an Interface and why would you use one over the other? It seems like a simple question but most often, the answer to this question seems insufficient for the interviewer and can cost a job. So, I decided to write a series of articles about them and have tried to explain it in as simple a manner as I can. 

Regarding the title of the series, my intention is not to portray these concepts as Villains. These are the most important concepts in programming and without them we cannot achieve better code efficiency. This series is all about their role in a technical interview. If you haven't prepared them good, it can cost you a job. So, these concepts are not villains but their role in an interview surely is. I always try to learn a new concept with the simple approach: "What, Why and How".

• What: What is it?
• Why: Why do I need to learn it?
• How: How can I work with it?

I used the same approach to write this article. This is the first article of the series and focus on Abstract Class. In my next article, I'll talk about Interface.

Roadmap

Here is the road map of the series of articles under the title "Abstract Class & Interface: Two Villains of Every Interview".

 

Abstract Class
 What is an Abstract Class? 

The dictionary meaning of the word "abstract" is a thought or idea that has no physical existence and is just conceptual. We can use the idea to build something of a physical existence. In the MSDN Library, the "abstract" keyword indicates that the thing has a missing or incomplete implementation and must be completed by others. 

The abstract keyword can be used with classes, methods, properties, indexers and events. If we use the abstract keyword with a class, it indicates that the class is intended to be a base class and can have abstract methods (ideas) that must be implemented in a derived class (physical existence).

An abstract class is a special kind of class that has no implementation. It cannot be instantiated. Its implementation logic is provided by the classes that derive from it. It can have both abstract as well as non-abstract methods. 
It is not compulsory to have only abstract methods in an abstract class. We can also have an abstract class with only non-abstract methods. 


Why do we need an Abstract Class? 
With an Abstract Class, we can provide some kind of default functionality for all derived classes to extend from. This is useful to avoid code duplication in many cases. 

Suppose we are defining an iPhone class for Apple and then inheriting it to iPhone5 and iPhone5s subclasses. Practically we don't want an object of an iPhone class since we first need to know the model of iPhone. So, the iPhone class should be an abstract class that contains some predefined functions like Call() and SMS() for all iPhone models to share . We can also add abstract methods like Model() and Color() into the iPhone class that must be implemented by all the subclasses inheriting iPhone. The main advantage of this approach is, whenever we inherit the iPhone class into a derived class, say iPhone5s, we need not define the Call() and SMS() methods again. We just need to implement the abstract methods and we are good to go. It helps to provide default functionality in all the derived classes and also avoids code duplication. 

Abstract classes are also useful in the case of modifications to the project. If you plan on updating the base class in your project, it is better to make the class abstract. Because you can define a functionality in an abstract base class and automatically all the inheriting classes will have the same functionality without disturbing the hierarchy.


How to define an Abstract Class 
As we have discussed earlier, classes can be declared as abstract by putting the keyword abstract before the class definition. So, let's get started with Abstract Class by using a simple console application. 

Create a console application project in Visual Studio and name it "AbstractClassDemo".

By default, it gives a class named Program with Main method in it for code execution. We can create an abstract class by putting the keyword abstract before a class definition as follows: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone { } //Definition of an Abstract Class   
6.     class Program   
7.     {   
8.         static void Main(string[] args) { }   
9.     }   
10. }  

The code above defines a simple abstract class. However, we cannot create an object/instance of abstract class. It gives us an error straightaway. 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone { }   
6.     class Program   
7.     {   
8.         static void Main(string[] args)   
9.         {   
10.             //Instantiation of an Abstract Class   
11.             iPhone iphone = new iPhone();   
12.         }   
13.     }   
14. }   

So, we need to define members in it that can be in derived classes. We can define abstract as well as non-abstract members in an abstract class. An abstract class with non-abstract method is as follows: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.     }  
13.     class Program   
14.     {   
15.         static void Main(string[] args)   
16.         {   
17.         }   
18.     }   
19. }   

The iPhone class shows a non-abstract method Call() that provides the default functionality to all sub classes that are derived from it. We cannot create an object of iPhone class but we can still use the Call() method in derived classes. 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.     }   
13.       
14.     class Program: iPhone   
15.     {   
16.         static void Main(string[] args)   
17.         {   
18.             //Instance Creation of Derived Class   
19.             Program program = new Program();   
20.             program.Call();   
21.             Console.ReadKey();   
22.         }   
23.     }   
24. }    

The code above shows a simple inheritance of an abstract class into a concrete class. This type of inheritance can also be done by two concrete classes. So, why do we want an abstract class? 

The answer is, to provide default functionality and to add abstract methods. The iPhone class is inherited by all iPhone models, so the Call() method is required in all the models. It is better to define a Call() method in the abstract class so that each derived class can have the Call() method automatically and doesn't need to define it again. 

Each iPhone model has some of its own features like Color and Model. So, we can define a contract in an abstract class that must be implemented in derived classes as per their requirements. These types of contracts are called abstract methods and in this example is Model(). Abstract methods only have a signature and no implementation. It is a kind of contract that forces all the subclasses to implement it. 

Like the abstract class, abstract methods are also declared using the abstract keyword. It may be noted that an abstract method cannot be private or it gives an error: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.       
13.         //Abstract Method kept as Private   
14.         abstract void Model();   
15.     }   
16.   
17.     class Program   
18.     {   
19.         static void Main(string[] args)   
20.         {   
21.         }   
22.     }   
23. }  

If we compile this code, it gives us an error: 



So, the correct way to declare an abstract method is as follows: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.   
13.         //Abstract Method   
14.         public abstract void Model();   
15.     }   
16.   
17.     class Program   
18.     {   
19.         static void Main(string[] args)   
20.         {   
21.         }   
22.     }   
23. }  

The Model() method enforces all the derived classes to implement it. We can define a new concrete class iPhone5s that inherits the abstract class iPhone and provides the definition of Model() method. 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.       
13.         //Abstract Method   
14.         public abstract void Model();   
15.     }   
16.   
17.     class iPhone5s: iPhone   
18.     {   
19.     }   
20.   
21.     class Program   
22.     {   
23.         static void Main(string[] args)   
24.         {   
25.         }   
26.     }   
27. }  

If we don't provide the definition of the abstract method in the derived class, it throws an error:

Ok. Let's provide the definition of Model() method in the derived class: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.       
13.         //Abstract Method   
14.         public abstract void Model();   
15.     }   
16.   
17.     class iPhone5s: iPhone   
18.     {   
19.         //Abstract Method Implementation   
20.         public void Model()   
21.         {   
22.             Console.WriteLine("Model: The model of this iPhone is iPhone5s");   
23.         }   
24.     }   
25.   
26.     class Program   
27.     {   
28.         static void Main(string[] args)   
29.         {   
30.         }   
31.     }   
32. }   

Now we have defined the Model() method in the class iPhone5s. Let's compile the code above. Whoa, it gives us an error plus a warning. 



The error says "The Model() method is not implemented in derived class". It seems fair since we aren't overriding the base method, which means the compiler believe that there is no implementation of the Model() method in the derived class. 
It also gives us a warning  "To make the current member override that implementation, add the override keyword, otherwise add the new keyword". It means that the compiler is confused about the Model() method we declared in the iPhone5s class. 

If you want to override the base class method in derived class, use the override keyword with the method and if your derived class method is not related in any way with the base class method, use the new keyword. The new keyword signifies that the method in the derived class has nothing to do with the base class method.

In our case, we want the base class method to be defined in the derived class. So, we use the override keyword. Also, we can add local methods in the iPhone5s class: 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         //Non-Abstract Method   
8.         public void Call()   
9.         {   
10.             Console.WriteLine("Call Method: This method provides Calling features");   
11.         }   
12.       
13.         //Abstract Method   
14.         public abstract void Model();   
15.     }   
16.   
17.     class iPhone5s: iPhone   
18.     {   
19.         //Abstract Method Implementation   
20.         public override void Model()   
21.         {   
22.             Console.WriteLine("Model: The model of this iPhone is iPhone5s");   
23.         }   
24.       
25.         //Derived Class Local Method   
26.         public void LaunchDate()   
27.         {   
28.             Console.WriteLine("Launch Date: This iPhone was launched on 20- September-2013");   
29.         }   
30.     }   
31.       
32.     class Program   
33.     {   
34.         static void Main(string[] args)   
35.         {   
36.               
37.         }   
38.     }   
39. }   

All good. Let's use the iPhone5s class that now has methods from the abstract class as well as its own methods. 

1. using System;   
2.   
3. namespace AbstractClassDemo   
4. {   
5.     abstract class iPhone   
6.     {   
7.         public void Call()   
8.         {   
9.             Console.WriteLine("Call Method: This method provides Calling features");   
10.         }      
11.         public abstract void Model();   
12.     }   
13.   
14.     class iPhone5s: iPhone   
15.     {  
16.         public override void Model()   
17.         {   
18.             Console.WriteLine("Model: The model of this iPhone is iPhone5s");   
19.         }   
20.   
21.         public void LaunchDate()   
22.         {   
23.             Console.WriteLine("Launch Date: This iPhone was launched on 20-September-2013");   
24.         }   
25.     }   
26.   
27.     class Program   
28.     {   
29.         static void Main(string[] args)   
30.         {   
31.             iPhone5s iphone5s = new iPhone5s();   
32.             iphone5s.Call();   
33.             iphone5s.Model();  
34.             iphone5s.LaunchDate();   
35.             Console.ReadKey();   
36.         }   
37.     }   
38. }   

If we run the code, it works perfectly.

In the preceding example, I explained how to use an abstract class in a very simple way. We are able to implement an abstract class and its abstract members into a concrete class. The following are some key points to be remembered when working with abstract classes. 

Key Points

1. We cannot create an object of Abstract Class but we can create a reference of it.
   1. using System;   
   2.   
   3. namespace AbstractClassDemo   
   4. {   
   5.     abstract class absClass { }   
   6.     class Program   
   7.     {   
   8.         public static void Main(string[] args)   
   9.         {   
   10.             //We can't do this   
   11.             //absClass cls = new absClass();   
   12.             //We can do this   
   13.             absClass cls;   
   14.         }   
   15.     }   
   16. }   
2. An inheritance between abstract to abstract classes is possible. We don't need to implement abstract methods of the base abstract class into a derived abstract class. We can implement it later in concrete classes. 
   1. using System;   
   2.   
   3. namespace AbstractClassDemo   
   4. {   
   5.     abstract class absClassA   
   6.     {   
   7.         //Abstract Method   
   8.         public abstract void SomeMethod();   
   9.     }   
   10.   
   11.     abstract class absClassB: absClassA //Abstract to Abstract Inheritance   
   12.     {   
   13.     }   
   14.   
   15.     class Program: absClassB   
   16.     {   
   17.         public override void SomeMethod()   
   18.         {   
   19.             //Some Implementation Here   
   20.         }   
   21.   
   22.         public static void Main(string[] args)   
   23.         {   
   24.         }   
   25.     }   
   26. }  
3. An abstract class can never be sealed or static. 
    
4. An abstract class can have abstract as well as non abstract methods. 
    
5. The abstract keyword can be used with class, methods, properties, indexers and events.
    
6. Abstract members can only be declared inside an abstract class. 
    
7. An abstract member cannot be static or private. 
    
8. An abstract method cannot be marked virtual. 
    
9. A concrete class cannot inherit more than one abstract class, in other words multiple Inheritance is not possible. 
    
10. Without an abstract class, we cannot implement the Template Method Pattern.

Conclusion
I hope this article helps you to understand the various possibilities of Abstract Classes. In Part 2 of my articles I'll talk about Interface and the difference between Abstract Class and Interface. Your feedback and constructive criticism is always appreciated, keep it coming. Until then, try to put a ding in the universe!

Source Collected from Csharpcorner.com

http://www.c-sharpcorner.com/UploadFile/d0e913/abstract-class-interface-two-villains-of-every-interview/