Un Interfaz en Java El lenguaje de programación se define como un tipo abstracto utilizado para especificar el comportamiento de una clase. Una interfaz en Java es un modelo de un comportamiento. Una interfaz Java contiene constantes estáticas y métodos abstractos.

¿Qué son las interfaces en Java?

La interfaz en Java es a mecanismo para lograr abstracción . Sólo puede haber métodos abstractos en la interfaz Java, no el cuerpo del método. Se utiliza para lograr la abstracción y herencias múltiples en Java usando la interfaz . En otras palabras, se puede decir que las interfaces pueden tener métodos y variables abstractos. No puede tener un cuerpo de método. Interfaz Java también representa la relación IS-A .

Cuando decidimos un tipo de entidad por su comportamiento y no por atributo debemos definirla como una interfaz.

Sintaxis para interfaces Java

interface {  // declare constant fields  // declare methods that abstract   // by default.  }>

Para declarar una interfaz, utilice la palabra clave interfaz. Se utiliza para proporcionar una abstracción total. Eso significa que todos los métodos en una interfaz se declaran con un cuerpo vacío y son públicos y todos los campos son públicos, estáticos y finales de forma predeterminada. Una clase que implementa una interfaz debe implementar todos los métodos declarados en la interfaz. Para implementar la interfaz, utilice la palabra clave implements.

Usos de interfaces en Java

Los usos de las interfaces en Java se mencionan a continuación:

• Se utiliza para lograr la abstracción total.
• Dado que Java no admite herencias múltiples en el caso de clases, al utilizar una interfaz puede lograr herencias múltiples.
• Cualquier clase puede extender solo 1 clase, pero cualquier clase puede implementar un número infinito de interfaces.
• También se utiliza para lograr un acoplamiento flojo.
• Las interfaces se utilizan para implementar la abstracción.

Entonces surge la pregunta de ¿por qué usar interfaces cuando tenemos clases abstractas?

La razón es que las clases abstractas pueden contener variables no finales, mientras que las variables en la interfaz son finales, públicas y estáticas.

// A simple interface interface Player {  final int id = 10;  int move(); }>

Relación entre clase e interfaz

Una clase puede extender otra clase similar a esta, una interfaz puede extender otra interfaz. Pero sólo una clase puede extenderse a otra interfaz y viceversa no está permitido.

java reemplaza toda la cadena

Diferencia entre clase e interfaz

Aunque Clase e Interfaz parecen iguales, existen ciertas diferencias entre Clases e Interfaz. Las principales diferencias entre una clase y una interfaz se mencionan a continuación:

Implementación: Para implementar una interfaz, usamos la palabra clave implementos

// Java program to demonstrate working of // interface import java.io.*; // A simple interface interface In1 {    // public, static and final  final int a = 10;  // public and abstract  void display(); } // A class that implements the interface. class TestClass implements In1 {    // Implementing the capabilities of  // interface.  public void display(){   System.out.println('Geek');   }  // Driver Code  public static void main(String[] args)  {  TestClass t = new TestClass();  t.display();  System.out.println(t.a);  } }>

Geek 10>

Ejemplos de interfaces Java

Consideremos el ejemplo de vehículos como bicicletas, coches, bicis, etc., tienen funcionalidades comunes. Entonces creamos una interfaz y ponemos todas estas funcionalidades comunes. Y permite que Bicicleta, Bicicleta, Coche, etc. implementen todas estas funcionalidades en su propia clase a su manera.

A continuación se muestra la implementación del tema anterior:

// Java program to demonstrate the  // real-world example of Interfaces import java.io.*; interface Vehicle {    // all are the abstract methods.  void changeGear(int a);  void speedUp(int a);  void applyBrakes(int a); } class Bicycle implements Vehicle{    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  } } class Bike implements Vehicle {    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  }   } class GFG {    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);    System.out.println('Bicycle present state :');  bicycle.printStates();    // creating instance of the bike.  Bike bike = new Bike();  bike.changeGear(1);  bike.speedUp(4);  bike.applyBrakes(3);    System.out.println('Bike present state :');  bike.printStates();  } }>

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

Ventajas de las interfaces en Java

Las ventajas de utilizar interfaces en Java son las siguientes:

mysql muestra todos los usuarios

• Sin preocuparnos por la parte de implementación, podemos lograr la seguridad de la implementación.
• En Java, no se permiten herencias múltiples; sin embargo, puede usar una interfaz para utilizarla, ya que puede implementar más de una interfaz.

Herencia múltiple en Java usando la interfaz

La herencia múltiple es un concepto de programación orientada a objetos que no se puede implementar en Java mediante clases. Pero podemos usar herencias múltiples en Java usando Interface. Comprobemos esto con un ejemplo.

Ejemplo:

// Java program to demonstrate How Diamond Problem // Is Handled in case of Default Methods // Interface 1 interface API {  // Default method  default void show()  {  // Print statement  System.out.println('Default API');  } } // Interface 2 // Extending the above interface interface Interface1 extends API {  // Abstract method  void display(); } // Interface 3 // Extending the above interface interface Interface2 extends API {  // Abstract method  void print(); } // Main class // Implementation class code class TestClass implements Interface1, Interface2 {  // Overriding the abstract method from Interface1  public void display()  {  System.out.println('Display from Interface1');  }  // Overriding the abstract method from Interface2  public void print()  {  System.out.println('Print from Interface2');  }  // Main driver method  public static void main(String args[])  {  // Creating object of this class  // in main() method  TestClass d = new TestClass();  // Now calling the methods from both the interfaces  d.show(); // Default method from API  d.display(); // Overridden method from Interface1  d.print(); // Overridden method from Interface2  } }>

Default API>

Nuevas características agregadas en interfaces en JDK 8

Hay ciertas características agregadas a las interfaces en la actualización JDK 8 que se mencionan a continuación:

1. Antes de JDK 8, la interfaz no podía definir la implementación. Ahora podemos agregar una implementación predeterminada para los métodos de interfaz. Esta implementación predeterminada tiene un uso especial y no afecta la intención detrás de las interfaces.

Supongamos que necesitamos agregar una nueva función a una interfaz existente. Obviamente, el código antiguo no funcionará porque las clases no han implementado esas nuevas funciones. Entonces, con la ayuda de la implementación predeterminada, proporcionaremos un cuerpo predeterminado para las funciones recién agregadas. Entonces los códigos antiguos seguirán funcionando.

A continuación se muestra la implementación del punto anterior:

// Java program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  default void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  TestClass t = new TestClass();  t.display();  } }>

hello>

2. Otra característica que se agregó en JDK 8 es que ahora podemos definir métodos estáticos en interfaces que se pueden llamar de forma independiente sin un objeto.

Nota: Estos métodos no se heredan.

// Java Program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  static void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  In1.display();  } }>

hello>

Ampliación de interfaces

Una interfaz puede heredar otra mediante el uso de la palabra clave extends. Cuando una clase implementa una interfaz que hereda otra interfaz, debe proporcionar una implementación para todos los métodos requeridos por la cadena de herencia de la interfaz.

alfabeto de números

Programa 1:

interface A {  void method1();  void method2(); } // B now includes method1 and method2 interface B extends A {  void method3(); } // the class must implement all method of A and B. class gfg implements B {  public void method1()  {  System.out.println('Method 1');  }  public void method2()  {  System.out.println('Method 2');  }  public void method3()  {  System.out.println('Method 3');  } }>

Programa 2:

interface Student  {  public void data();   } class avi implements Student {  public void data ()  {  String name='avinash';  int rollno=68;  System.out.println(name);  System.out.println(rollno);  } } public class inter_face  {  public static void main (String args [])  {  avi h= new avi();  h.data();  } }>

avinash 68>

De forma sencilla, la interfaz contiene múltiples métodos abstractos, así que escriba la implementación en clases de implementación. Si la implementación no puede proporcionar una implementación de todos los métodos abstractos, entonces declare la clase de implementación con un modificador abstracto y complete la implementación del método restante en las siguientes clases secundarias creadas. Es posible declarar varias clases secundarias, pero al final hemos completado la implementación de todos los métodos abstractos.

En general, el proceso de desarrollo es paso a paso:

Nivel 1 – interfaces: Contiene los detalles del servicio.
Nivel 2 – clases abstractas: Contiene implementación parcial.
Nivel 3 – clases de implementación: contiene todas las implementaciones.
Nivel 4 – Código final / Método principal: Tiene acceso a todos los datos de las interfaces.

Ejemplo:

// Java Program for // implementation Level wise import java.io.*; import java.lang.*; import java.util.*; // Level 1 interface Bank {  void deposit();  void withdraw();  void loan();  void account(); } // Level 2 abstract class Dev1 implements Bank {  public void deposit()  {  System.out.println('Your deposit Amount :' + 100);  } } abstract class Dev2 extends Dev1 {  public void withdraw()  {  System.out.println('Your withdraw Amount :' + 50);  } } // Level 3 class Dev3 extends Dev2 {  public void loan() {}  public void account() {} } // Level 4 class GFG {  public static void main(String[] args)  {  Dev3 d = new Dev3();  d.account();  d.loan();  d.deposit();  d.withdraw();  } }>

Your deposit Amount :100 Your withdraw Amount :50>

Nuevas características agregadas en interfaces en JDK 9

Desde Java 9 en adelante, las interfaces también pueden contener lo siguiente:

1. Métodos estáticos
2. métodos privados
3. Métodos estáticos privados

Puntos importantes en las interfaces Java

En el artículo, aprendemos ciertos puntos importantes sobre las interfaces como se menciona a continuación:

• No podemos crear una instancia (no se puede crear una instancia de la interfaz) de la interfaz, pero podemos hacer la referencia de la misma que se refiere al Objeto de su clase implementadora.
• Una clase puede implementar más de una interfaz.
• Una interfaz puede extenderse a otra interfaz o interfaz (más de una interfaz).
• Una clase que implementa la interfaz debe implementar todos los métodos de la interfaz.
• Todos los métodos son públicos y abstractos. Y todos los campos son públicos, estáticos y finales.
• Se utiliza para lograr herencias múltiples.
• Se utiliza para lograr un acoplamiento flojo.
• Dentro de la interfaz no es posible declarar variables de instancia porque, de forma predeterminada, las variables son final estática pública.
• Dentro de la Interfaz, no se permiten constructores.
• Dentro de la interfaz, el método principal no está permitido.
• Dentro de la interfaz, no es posible la declaración de métodos estáticos, finales y privados.

Debe leer

• Especificador de acceso a métodos en interfaces
• Especificadores de acceso para clases o interfaces en Java
• Clases abstractas en Java
• Interfaz de comparador en Java
• Métodos de interfaz Java
• Interfaz anidada en Java

Preguntas frecuentes sobre interfaces

1. ¿Qué es un marcador o interfaz etiquetada?

Las interfaces etiquetadas son interfaces sin ningún método y sirven como marcador sin ninguna capacidad.

2. ¿Cuántos tipos de interfaces hay en Java?

Los tipos de interfaces en Java se mencionan a continuación:

1. Interfaz funcional
2. Interfaz de marcador

3. ¿Por qué no se admite la herencia múltiple a través de clases en Java?

La herencia múltiple no se admite a través de clases en Java, para evitar ciertos desafíos como la ambigüedad y los problemas de diamantes.