Tutorialspoint.dev

C# | Interface

Like a class, Interface can have methods, properties, events, and indexers as its members. But interfaces will contain only the declaration of the members. The implementation of interface’s members will be given by class who implements the interface implicitly or explicitly.

  • Interfaces specify what a class must do and not how.
  • Interfaces can’t have private members.
  • By default all the members of Interface are public and abstract.
  • The interface will always defined with the help of keyword ‘interface‘.
  • Interface cannot contain fields because they represent a particular implementation of data.
  • Multiple inheritance is possible with the help of Interfaces but not with classes.

Syntax for Interface Declaration:

interface  <interface_name >
{
    // declare Events
    // declare indexers
    // declare methods 
    // declare properties
}

Syntax for Implementing Interface:

class class_name : interface_name

To declare an interface, use interface keyword. It is used to provide total abstraction. That means all the members in the interface are declared with the empty body and are public and abstract by default. A class that implement interface must implement all the methods declared in the interface.

  • Example 1:
    // C# program to demonstrate working of 
    // interface
    using System;
      
    // A simple interface
    interface inter1
    {
        // method having only declaration 
        // not definition
        void display();
    }
      
    // A class that implements interface.
    class testClass : inter1
    {
          
        // providing the body part of function
        public void display()
        {
            Console.WriteLine("Sudo Placement GeeksforGeeks");
        }
      
        // Main Method
        public static void Main (String []args)
        {
              
            // Creating object
            testClass t = new testClass();
              
            // calling method
            t.display();
        }
    }

    Output:

    Sudo Placement GeeksforGeeks
    
  • Example 2:
    // C# program to illustrate the interface
    using System;
      
    // interface declaration
    interface Vehicle {
          
        // all are the abstract methods.
        void changeGear(int a);
        void speedUp(int a);
        void applyBrakes(int a);
    }
      
    // class implements interface
    class Bicycle : Vehicle{
          
        int speed;
        int gear;
          
        // to change gear
        public void changeGear(int newGear)
        {
              
            gear = newGear;
        }
          
        // to increase speed
        public void speedUp(int increment)
        {
              
            speed = speed + increment;
        }
          
        // to decrease speed
        public void applyBrakes(int decrement)
        {
              
            speed = speed - decrement;
        }
          
        public void printStates() 
        {
            Console.WriteLine("speed: " + speed + 
                              " gear: " + gear);
        }
    }
      
    // class implements interface
    class Bike : Vehicle {
          
        int speed;
        int gear;
          
        // to change gear
        public void changeGear(int newGear)
        {
              
            gear = newGear;
        }
          
        // to increase speed
        public void speedUp(int increment)
        {
              
            speed = speed + increment;
        }
          
        // to decrease speed
        public void applyBrakes(int decrement){
              
            speed = speed - decrement;
        }
          
        public void printStates() 
        {
            Console.WriteLine("speed: " + speed + 
                              " gear: " + gear);
        }
          
    }
      
    class GFG {
          
        // Main Method
        public static void Main(String []args) 
        {
          
            // creating an instance of Bicycle 
            // doing some operations 
            Bicycle bicycle = new Bicycle();
            bicycle.changeGear(2);
            bicycle.speedUp(3);
            bicycle.applyBrakes(1);
              
            Console.WriteLine("Bicycle present state :");
            bicycle.printStates();
              
            // creating instance of bike.
            Bike bike = new Bike();
            bike.changeGear(1);
            bike.speedUp(4);
            bike.applyBrakes(3);
              
            Console.WriteLine("Bike present state :");
            bike.printStates();
        }
    }

    Output:

    Bicycle present state :
    speed: 2 gear: 2
    Bike present state :
    speed: 1 gear: 1
    

Advantage of Interface:

  • It is used to achieve loose coupling.
  • It is used to achieve total abstraction.
  • To achieve component-based programming
  • To achieve multiple inheritance and abstraction.
  • Interfaces add a plug and play like architecture into applications.


  • This article is attributed to GeeksforGeeks.org

    leave a comment

    code

    0 Comments

    load comments

    Subscribe to Our Newsletter