Advertisement

---

Top

< Prev

Next >

In C#, an interface is a 100% abstract class that is declared with the interface keyword. Methods of interface are implicitly abstract, hence, when declaring an interface, you must not provide an implementation of its methods and its methods should end with a semicolon ;

interface A
{
	// Unlike regular methods, method of an interface 
	// should not be implemented within a pair of curly braces {} and,
	// should rather end with a semicolon.
	void GetName();  
}

Some important points about interface

• Interface methods are implicitly declared with the public access modifier and abstract keyword, which means that even if you don't explicitly type public and abstract with interface methods, they are still always public and abstract, by default.



//C# Example of an interface

//An interface
interface Math
{
	//The method Subtract() method is public and  abstract by default
	void Subtract(int a, int b);

	//The method Add() is public and abstract by default
	void Add(int a, int b);		
}


In the code above, we have created an interface named, Math with two methods - Subtract and Add(), and they are implicitly public and abstract. Each of these methods has a void return type and take two int parameters.





• A class can implement an interface by providing the internal logic of all methods of an interface, conforming to each of their method signatures.
  
  A general syntax of implementing an interface:

  class implementer-class-name : interface-name
  {
  //The body of a class, which is 
  //implementing an interface
  }

  
  
  • In the syntax, The implementer-class-name is the name of the class, which is being created by implementing an interface named interface-name.
  
  
  • The colon : between implementer-class-name and interface-name indicates whether a class is inheriting another class or a class is implementing an interface. i.e. some sort of inheritance is being performed.
  
  

  //C# Example of implementing an interface
  
  
  using System;
  
  //An interface
  interface Math
  {
  	//The method Subtract() method is public and  abstract by default
  	void Subtract(int a, int b);
  
  	//The method Add() is public and abstract by default
  	void Add(int a, int b);		
  }
  
  
  //class A implementing Math interface 
  class A:Math
  {
  //Implementing the method Subtract() of interface Math
  public void Subtract(int a, int b)
  {
  	Console.WriteLine("{0}-{1}: {2}",a, b, a-b);
  }
  
  
  //Implementing the method Add() of interface Math
  public void Add(int a, int b)
  {
  	Console.WriteLine("{0}+{1}: {2}",a, b, a+b);
  }
  
  public static void Main(String[] ar)
  {
  	//Creating an object of class A
  	//Which has implemented interface Math
  	A ob = new A();
  
  	//Calling the implemented method Subtract() of class A
  	ob.Subtract(10, 5);
  
  	//Calling the implemented method Add() of class A
  	ob.Add(10, 5);
  
  
  }
  }

  
  

  Output

  
  

  10-5: 5
  10+5: 15

  
  
  

  Program Analysis

  
  
  • An interface Math has declared two methods Add() and Subtract(), with their method signature as -
    • The access modifier is public by default.
    • A void return type.
    • Two int arguments in their parameters.
  • A concrete class A has implemented Math interface by providing an implementation of its two methods, by following their method signatures.
  • After a class implements an interface, the implemented methods of interface are inherited and become a part of the concrete class, so they can be called by using an object of the class.
  
  
  
  
  
  
  • An interface cannot contain the instance variables.
  
  

  //C# An interface cannot contain the instance variables
  
  
  using System;
  
  //An interface
  interface A
  {
  	int a = 10;
  }

  
  
  

  Output -

  
  

  A.cs(11,6): error CS0525: Interfaces cannot contain instance fields

  
  
  
  

  Advertisement

  
  
  
  
  • You cannot instantiate or create an object of an interface, because it is a 100% abstract and skeletal. Hence, instantiating an interface gives a compile error.
  
  

  //C# You cannot instantiate or create an object of an interface
  
  
  using System;
  
  //An interface
  interface A
  {
  	void MethodA();
  }
  
  class B
  {
  public static void Main(String[] ar)
  {
  	//instantiating an interface, throws a compile error.
  	A ob = new A();		
  }
  }

  
  
  

  Output -

  
  

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

  
  
  
  
  
  
  • An Interface can inherit multiple interfaces and it doesn't have to provide an implementation of methods of those interfaces.
  
  

  //C# An Interface can extend multiple interfaces and,
  //it doesn't have to provide an implementation of methods of those interfaces.
  
  
  using System;
  
  //First interface
  interface A
  {
  	void MethodA();
  }
  
  
  //Second interface
  interface B
  {
  	void MethodB();
  }
  
  
  //Third interface C, which is inheriting interface A and B
  //without providing implementation of their methods.
  interface C:A,B
  {
  }
  
  
  //A concrete class, D is implementing interface C
  class D:C
  {
  
  //Implementing method MethodA()
  //Which interface C inherited from interface A
  public void MethodA()
  {
  	Console.WriteLine("A");
  }
  
  
  //Implementing method MethodAB()
  //Which interface B inherited from interface A
  public void MethodB()
  {
  	Console.WriteLine("B");
  }
  
  public static void Main(String[] ar)
  {
  	//Creating an object of concrete class, D
  	//Which has implemented interface C
  	D ob = new D();
  
  	//Calling the implemented method, MethodA()
  	//by using the object of  class D
  	ob.MethodA();
  	
  	
  	//Calling the implemented method, MethodA()
  	//by using the object of  class D
  	ob.MethodB();	
  }
  }

  
  

  Output

  
  

  A
  B

  
  As you may see in the last program, interface C has inherited multiple interfaces A and B at once, without providing any implementation of their methods. Eventually, a concrete class D has implemented the interface C and has also provided the implementation of its two inherited methods- MethodA() and MethodB().
  
  
  
  
  
  • A class can implement multiple interfaces and it must provide an implementation of all their methods.
  
  

  //C# A class can implement multiple interfaces 
  //and it must provide an implementation of all their methods.
  
  
  using System;
  
  //First interface
  interface A
  {
  	void MethodA();
  }
  
  
  //Second interface
  interface B
  {
  	void MethodB();
  }
  
  
  //Third interface C, which is inheriting interface A and B
  //without providing implementation of their methods.
  //interface C:A,B
  //{
  //}
  
  
  //A concrete class, D is implementing interfaces A and B
  class D:A,B
  {
  
  //Implementing method MethodA()
  //Which is inherited from interface A
  public void MethodA()
  {
  	Console.WriteLine("A");
  }
  
  
  //Implementing method MethodAB()
  //Which is inherited from interface A
  public void MethodB()
  {
  	Console.WriteLine("B");
  }
  
  public static void Main(String[] ar)
  {
  	//Creating an object of concrete class, D
  	//Which has implemented interface C
  	D ob = new D();
  
  	//Calling the implemented method, MethodA()
  	//by using the object of  class D
  	ob.MethodA();
  	
  	
  	//Calling the implemented method, MethodA()
  	//by using the object of  class D
  	ob.MethodB();	
  }
  }

  
  

  Output

  
  

  A
  B

  
  Two interfaces- A and B are implemented by class D, which has implemented all of these interfaces by providing the internal logic of each of the methods in these interfaces by conforming to their signatures.
  
  
  
  
  
  • An abstract class can implement an interface and it doesn't have to implement its methods.
  
  

  //C# An abstract class can implement an interface and it doesn't have to implement its methods.
  
  using System;
  
  
  //An interface
  interface Math
  {
  //Signature of Add() method 
  int Add(int a, int b);	
  }
  
  
  //An abstract class implementing an interface
  //without having to implement its methods
  abstract class A:Math
  {
  //Implementing a method Add() of interface Math
  public int Add(int a, int b)
  {
  	return(a+b);
  }
  }
  
  
  //A concrete class inheriting abstract class, A
  class B:A
  {
  public static void Main(String[] ar)
  {
  	//Creating an object of class B
  	B ob = new B();
  
  	//Calling the inherited method of abstract class, A
  	//By using the object of class B
  	Console.WriteLine(ob.Add(10,20));
  }
  }

  
  

  Output

  
  

  A
  B

  
  An interface, Math has a skeletal method - Add(). An abstract class A has implemented the interface Math and hasn't provided internal logic of its methods.
  
  
  
  
  

  Why an abstract class can implement an interface without implementing its methods?

  
  Because as per the rule of an abstract class, an abstract class may have also some skeletal methods with no definition. Hence, it doesn't have to provide an implementation of skeletal methods of an interface while implementing it.
  
  
  
  
  

  Please share this article -

  
  
  
  
  
  < Prev
  Next >
  < Class Member Access Modifiers
  C# Abstract Class >

  
  
  Advertisement