C# | Interfaz

Al igual que una clase, la interfaz puede tener métodos, propiedades, eventos e indexadores como miembros. Pero las interfaces contendrán solo la declaración de los miembros. La implementación de los miembros de la interfaz estará dada por la clase que implementa la interfaz implícita o explícitamente.

  • Las interfaces especifican qué debe hacer una clase y no cómo.
  • Las interfaces no pueden tener miembros privados.
  • Por defecto, todos los miembros de Interface son públicos y abstractos.
  • La interfaz siempre se definirá con la ayuda de la palabra clave ‘ interfaz ‘.
  • La interfaz no puede contener campos porque representan una implementación particular de datos.
  • La herencia múltiple es posible con la ayuda de Interfaces pero no con clases.

Sintaxis para la declaración de interfaz:

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

Sintaxis para implementar la interfaz:

class class_name : interface_name

Para declarar una interfaz, use la palabra clave de interfaz . Se utiliza para proporcionar abstracción total. Eso significa que todos los miembros de la interfaz se declaran con el cuerpo vacío y son públicos y abstractos de forma predeterminada. Una clase que implementa interfaz debe implementar todos los métodos declarados en la interfaz.

  • Ejemplo 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();
        }
    }
    Producción:

    Sudo Placement GeeksforGeeks
    
  • Ejemplo 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();
        }
    }
    Producción:

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

Ventaja de la interfaz:

  • Se utiliza para lograr un acoplamiento flojo.
  • Se utiliza para lograr la abstracción total.
  • Para lograr la programación basada en componentes
  • Lograr herencia múltiple y abstracción.
  • Las interfaces agregan una arquitectura tipo plug and play a las aplicaciones.
  • Publicación traducida automáticamente

    Artículo escrito por Mithun Kumar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *