Here i will discuss about some OOP features. Today I am discussing about Abstract Class and its uses.
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.
It is not compulsory to have only
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.
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.
using System;
namespace AbstractClassDemo
{
abstract class iPhone { } //Definition of an Abstract Class
class Program
{
static void Main(string[] args) { }
}
}
The code above defines a simple abstract class. However, we cannot create an object/instance of abstractclass. It gives us an error straightaway.
using System;
namespace AbstractClassDemo
{
abstract class iPhone { } //Definition of an Abstract Class
class Program
{
static void Main(string[] args)
{
//Instantiation of an Abstract Class
iPhone iphone = new iPhone();
}
}
}
So,
we need to define members in it that can get inherited 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:
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This method provides Calling
features");
}
}
class Program
{
static void Main(string[] args)
{
}
}
}
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.
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This method provides Calling
features");
}
}
class Program: iPhone
{
static void Main(string[] args)
{
//Instance Creation of Derived Class
Program
program = new Program();
program.Call();
Console.ReadKey();
}
}
}
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?
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This method provides Calling
features");
}
//Abstract Method kept as Private
abstract void Model();
}
class Program
{
static void Main(string[] args)
{
}
}
}
If we compile this code, it gives us an error:
So, the correct way to declare an abstract method is as follows
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This
method provides Calling features");
}
//Abstract Method
public abstract void Model();
}
class Program
{
static void Main(string[] args)
{
}
}
}
The Model() method
enforces all the derived classes to implement it. We can define a new concrete
classiPhone5s that
inherits the abstract class iPhone and provides the definition of Model() method.
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This
method provides Calling features");
}
//Abstract Method
public abstract void Model();
}
class iPhone5s: iPhone
{
}
class Program
{
static void Main(string[] args)
{
}
}
}
If
we don't provide the definition of the abstract method in the derived class, it throws an
error:
So Let's provide the definition of Model() method in the derived class:
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This
method provides Calling features");
}
//Abstract Method
public abstract void Model();
}
class iPhone5s: iPhone
{
//Abstract Method Implementation
public void Model()
{
Console.WriteLine("Model: The model of this iPhone is iPhone5s");
}
}
class Program
{
static void Main(string[] args)
{
}
}
}
Now
we have defined the Model() method in the class iPhone5s. Let's compile the code above. We will see, 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 believes
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
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.
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This method provides Calling
features");
}
//Abstract Method
public abstract void Model();
}
class iPhone5s: iPhone
{
//Abstract Method Implementation
public override void Model()
{
Console.WriteLine("Model: The model of this iPhone is
iPhone5s");
}
//Derived Class Local Method
public void LaunchDate()
{
Console.WriteLine("Launch Date: This iPhone was launched on
20-September-2013");
}
}
class Program
{
static void Main(string[] args)
{
}
}
}
All
good. Let's use the iPhone5s class that now has methods from the abstract class
as well as its own methods.
using System;
namespace AbstractClassDemo
{
abstract class iPhone
{
//Non-Abstract Method
public void Call()
{
Console.WriteLine("Call Method: This method provides Calling
features");
}
//Abstract Method
public abstract void Model();
}
class iPhone5s: iPhone
{
//Abstract Method Implementation
public override void Model()
{
Console.WriteLine("Model: The model of this iPhone is iPhone5s");
}
//Derived Class Local Method
public void LaunchDate()
{
Console.WriteLine("Launch Date: This iPhone was launched on
20-September-2013");
}
}
class Program
{
static void Main(string[] args)
{
iPhone5s
iphone5s = new iPhone5s();
iPhone5s.Call();
iPhone5s.Model();
iPhone5s.LaunchDate();
Console.ReadKey();
}
}
}
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.
using System;
namespace AbstractClassDemo
{
abstract class absClass{ }
class Program
{
static void Main(string[] args)
{
//We can't do this
//absClass cls = new absClass();
//We can do this
absClass cls;
}
}
}
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.
using System;
namespace AbstractClassDemo
{
abstract class absClassA
{
//Abstract Method
public abstract void SomeMethod();
}
abstract class absClassB: absClassA
//Abstract
to Abstract Inheritance
{
}
class Program: absClassB
{
public override void SomeMethod()
{
//Some Implementation Here
}
public static void Main(string[] args)
{
}
}
}
3 => An abstract class can never be sealed or static. => An abstract class can have abstract as well as non abstract methods. => The abstract keyword can be used with class, methods, properties, indexers and events. => Abstract members can only be declared inside an abstract class. => An abstract member cannot be static or private.
=> An abstract method cannot be marked virtual.
=> A concrete class cannot inherit more than one abstract class, in other words multiple inheritance is not possible. => Without an abstract class, we cannot implement the Template Method Pattern.
Thats all about an abstract class from me . Next I will be here with Interface and its uses....
.jpg)
.jpg)
0 comments:
Post a Comment