Advertisement

---

Top

< Prev

Next >

An abstract class is declared with the abstract keyword. Unlike a regular class in C#, an abstract class may not only contain the regular methods, defined with curly braces { } but may also contain the abstract methods, ending with a semicolon; or a mix of regular and abstract methods.

What are abstract methods?

Abstract methods are not implemented in the abstract class and are declared with -:

• An abstract keyword.
• An access modifier.
• A return-type of this abstract method.
• A method name and parameters(if there are any) to be passed to it.

Please remember, the internal logic of an abstract method is not provided, which means that an abstract method is not defined within a pair of curly braces {} and it ends with a semicolon ;






An example of an abstract method -

abstract public void add();

In the example, we have declared a method add with an abstract keyword, which makes it an abstract method. T his method has a public access modifier and a void return-type, which means that this abstract method will not return any value. And as it should be, this abstract method ends with a semicolon ;

Please Note:

• An abstract method can be declared with the public or protected access modifier, because both modifiers allow an abstract method to be inherited by a concrete derived-class to provide the implementation of an abstract method.


• An abstract method should never be declared with a private access modifier because doing so will make this abstract method inaccessible to the concrete class that inherits the abstract class and wants to provide an implementation of its abstract method.

Advertisement

Some very important points about an abstract class.

• To make an abstract class, you must declare a class with an abstract keyword.



//C# Example of an abstract class
//With two abstract methods

using System;

abstract class A
{
//An abstract method Add()
//It ends with a semicolon;
public abstract int Add(int a, int b);


//An abstract Subtract() method 
//It ends with a semicolon; as well
public abstract int Subtract(int a, int b);
}


We have created an abstract class A by declaring it with the abstract keyword. This abstract class has two abstract methods Add() and Subtract(), also declared with the abstract keyword and public access modifier.





• An abstract class may have a mixed set of abstract and regular(non-abstract) methods.



//C# Example of an abstract class
//With a mix of abstract, ending with a semicolon;
//And, a regular(non-abstract) method, with its implementation provided between { }
using System;

abstract class A
{

//An abstract method Add()
//It ends with a semicolon;
public abstract int Add(int a, int b);

//A regular(non-abstract) Subtract() method of abstract class
int Subtract(int a, int b)
{
	return (a-b);
}
}


An Abstract class A is declared with an abstract method, Add() and also a concrete method, Subtract().





• When a regular class inherits an abstract class, it must implement the abstract methods of an abstract class, or a compile error is issued.

When a regular class inherits an abstract class, it must implement the abstract methods of an abstract class, by using the override modifier, because we are overriding the abstract implementation of an abstract method.



//C# Example of an abstract class being inherited by a concrete class
//The concrete class will provide implementation of the abstract methods of the inherited abstract class.

using System;


//An abstract class 
abstract class A
{

//An abstract method Add()
//It ends with a semicolon;
public abstract int Add(int a, int b);

//A non-abstract Subtract() method of abstract class
int Subtract(int a, int b)
{
	return (a-b);
}
}



//A concrete class is inheriting abstract class A
class B:A
{
//Providing the implementation of the abstract method of abstract class A
//By using the override modifier
public override int Add(int a, int b)
{
	return (a+b);
}

public static void Main(String[] ar)
{
	B ob = new B();
	Console.WriteLine(ob.Add(2,3));
}
}





Output




5



• In the last example, we have created an abstract class A with an abstract method Add() and a regular(non-abstract) method Subtract().
• A concrete class B inherits the abstract class A and provides the implementation of the abstract method of abstract class A and inherits its already implemented regular(non-abstract) method.
• Note: If class B doesn't provide the implementation of the abstract method of abstract class A, the compiler would report a compile error.






• You can even create an abstract class which only contains concrete regular(non-abstract) methods and no abstract methods.



//C# Example of creating an abstract class which only contains 
//concrete regular methods and no abstract methods.


using System;


//An abstract class
//With only regular(non-abstract) method in it
abstract class A
{
//instance variable
public int i=10;


//A regular(non-abstract) method
public void Method()
{
	Console.WriteLine("A");
}
}


//A concrete class B is inherting abstract class A
class B:A
{
public static void Main(String[] ar)
{
 	//Creating an object of concrete class B
	B ob = new B();

	//Calling the regular inherited method, Method()
	//Using object of concrete class B
	ob.Method();

	//Accessing the inherited instance variable, i
	//Using object of concrete class B
	Console.WriteLine(ob.i);
}
}


An abstract method in an abstract class is not a must. Hence, in the code above, we have created an abstract class A with its members - a concrete method Method() and an int instance variable, but no abstract method and that's fine.





• You must declare a class with the abstract keyword, even when there is only a single abstract method in it.



//C# You must declare a class with the abstract keyword, 
//even when there is only a single abstract method in it



//Abstract method
class A
{

//An abstract method
abstract public void M();


//A non-abstract regular method
public void M2()
{
	Console.WriteLine("Concrete method of abstract class");
}
}





After Compilation




A.cs(11,22): error CS0513: 'A.m()' is abstract but it is contained in non-abstract class 'A'


The program issues a compile error because class A contains an abstract method M() but class A isn't declared as an abstract class. Therefore, class A must be declared abstract.





• An Abstract class cannot be instantiated, because it is created to be inherited by a concrete class.
  



//C# An abstract class cannot be instantiated


using System;

//Abstract class
abstract class A
{
//An abstract method
public abstract void Method1();

//A regular(non-abstract) method
public void Method2()
{
	Console.WriteLine("Hello");
}
}


class Ex
{
public static void Main(String[] ar)
{
	//Creating an object of abstract class
	//This should issue a compile error
	A ob = new A();
}
}





After Compilation




A.cs(26,9): error CS0144: Cannot create an instance of the abstract class or interface 'A'







• An abstract class can inherit another abstract class without providing the internal logic of the abstract methods of the abstract class it has inherited.



//C# Example of an abstract class inheriting another abstract class

using System;


//An abstract class 
abstract class A
{
abstract public void Message();
}

//An abstract class B inheriting another abstract class A
abstract class B:A
{
}

//A concrete class Ex inheriting abstract class B(which has inherited abstract class A)
class Ex:B
{
//Overriding the inherited abstract method
//By providing its implementation
public override void Message()
{
	Console.WriteLine("Hello!");
}


public static void Main(String[]ar)
{
	//Creating an object of concrete class Ex
	Ex ob = new Ex();

	//Calling the inherited and implemented method of abstract class
	ob.Message();
}
}




Output




Hello!


We have created an abstract class A with an abstract method Message(). Another abstract class B inherits the abstract class A and it does not have to provide the implementation of the inherited abstract method Message() of abstract class A.





• An abstract class can inherit and interface but it MUST provide an implementation of each method of an interface, because they are all abstract by default.

//C# Example of an abstract class inheriting another abstract class

using System;


//An interface 
interface A
{
//The method of interface method is abstract and public by default 
void Message();
}


//An abstract class B inheriting an interface A
abstract class B:A
{
//Providing the implementation of the inherited method of interface
//Which is a MUST in this case
public void Message()
{
	Console.WriteLine("Hello!");
}
}


//A concrete class Ex inheriting abstract class B(which has inherited interface A)
class Ex:B
{
public static void Main(String[]ar)
{
	//Creating an object of concrete class Ex
	Ex ob = new Ex();

	//Calling the inherited and implemented method of abstract class
	ob.Message();
}
}

Output

Hello!

An abstract class B has implemented an interface A and has also implemented its method Message(). Not implementing the abstract method of an interface by the inheriting abstract class, would've issued a compile error.

Please share this article -

< Prev

Next >

< C# Interface

C# Method Return Types >

Advertisement