¿Qué tipos de Java pueden implementar interfaces?

En Java no existe el concepto de herencia múltiple, pero con la ayuda de la interfaz podemos lograr la herencia múltiple. Una interfaz es una colección nombrada de definición. (sin implementación)

Una interfaz en Java es un tipo especial de clase. Al igual que las clases, la interfaz contiene métodos y miembros; a diferencia de las clases, en la interfaz todos los miembros son finales y todos los métodos son abstractos. 

• No podemos instanciar una interfaz en Java, lo que significa que no podemos crear un objeto de la clase de interfaz.
• Una clase que implementa una interfaz debe proporcionar una implementación para todos sus métodos a menos que sea una clase abstracta.
• De forma predeterminada, cualquier atributo de la interfaz es público, estático y final. Por lo tanto, no es necesario proporcionar un modificador de acceso al atributo, pero si cumple, tampoco se queja.
• Por defecto, los métodos son implícitamente abstractos y públicos, tiene mucho sentido porque los métodos no tienen un cuerpo y, por lo tanto, las subclases pueden proporcionar la implementación del método.
• Los métodos estáticos no se pueden declarar en las interfaces: estos métodos nunca son abstractos y no expresan el comportamiento del objeto.

Interfaz de implementación de tipos de Java

Hay principalmente 5 tipos de Java que pueden implementar interfaces que se enumeran a continuación, que exploraremos más adelante para profundizar de la siguiente manera:

1. Clase Java
2. Clase abstracta de Java
3. Clase anidada de Java
4. Enumeración de Java
5. Proxy dinámico de Java

Tipo 1: Clase Java

Cuando una clase implementa una interfaz, esencialmente está firmando un contrato. La clase debe implementar todos los métodos declarados en la interfaz y sus superinterfaces, o la clase debe declararse abstracta.

Para declarar una clase que implementa una interfaz, incluya una palabra clave implements en la declaración de la clase. Su clase puede implementar más de una interfaz, por lo que la palabra clave implements va seguida de una lista separada por comas de las interfaces implementadas por la clase.

Ejemplo

// Java Program illustrating Java Class implementing
// Interfaces
  
// Importing I/O classes
import java.io.*;
  
interface Animal {
  
    // final public static int x = 4;
    // public, static and final
    int x = 4;
  
    // Public and abstract
    void sound();
}
  
// Class implementing interface
class Chicks implements Animal {
  
    // Implementing the abstract method
    public void sound() { System.out.println("cheep"); }
  
    // Main driver method
    public static void main(String[] args)
    {
        Chicks c = new Chicks();
        c.sound();
        System.out.println("The value of x = " + x);
    }
}

cheep
The value of x = 4

Tipo 2: clase abstracta de Java

Las clases abstractas y de interfaz son similares en muchos aspectos, pero una clase abstracta permite herencia única, mientras que la interfaz permite herencias múltiples. Si una clase incluye una interfaz pero no implementa completamente los métodos requeridos por la interfaz, entonces la clase debe declararse como una clase abstracta.

Cuando implementamos una interfaz a una clase abstracta, significa que la clase abstracta heredó todos los métodos de la interfaz. No es necesario implementar todos los métodos en una clase abstracta, sin embargo, se trata de una clase abstracta (también por herencia), por lo que la clase abstracta puede dejar algunos de los métodos en la interfaz sin implementación aquí. Pero, cuando esta clase abstracta sea heredada por alguna clase, deben implementar todos esos métodos no implementados allí en la clase abstracta.

Ejemplo

// Java Program illustrating Java Abstract Class
// implementing Interfaces
  
// Importing I/O classes
import java.io.*;
  
interface Animal {
    public void sound();
    public void breed();
}
  
abstract class Cat implements Animal {
  
    // Note: It is is not necessary to implement
    // all methods of interface class
  
    public void sound() { System.out.println("meow"); }
}
  
public class Cat1 extends Cat {
    public void breed() { System.out.println("Ragdoll"); }
}
  
class Main {
    public static void main(String[] args)
    {
        Cat1 c = new Cat1();
        c.breed();
        c.sound();
    }
}

Ragdoll
meow

Tipo 3: clase anidada de Java

Java tiene la capacidad de anidar una clase dentro de una interfaz. La clase anidada es implícitamente pública y estática. La clase anidada dentro de la interfaz puede ser útil, especialmente cuando existe una relación entre la interfaz envolvente y la clase adjunta. La clase de anidamiento dentro de la interfaz puede mejorar la legibilidad del código fuente. La clase y la interfaz con el mismo nombre, el anidamiento también puede ayudarlo a evitar un conflicto de nombres entre los dos.

Ejemplo

// Java Program illustrating Java Nested Classes
// implementing Interfaces
  
// Importing I/O classes
import java.io.*;
  
interface Animal {
  
    // Nested class
    public class Type {
  
        public static void animal()
        {
            System.out.println("The animal is cat");
        }
    }
  
    public void breed();
    public void sound();
}
  
public class Cat implements Animal {
  
    // Method 1
    public void breed() { System.out.println("Munchkin"); }
  
    // Method 2
    public void sound() { System.out.println("Meow"); }
}
  
// Main class 
class MainClass {
    public static void main(String args[])
    {
        Cat c = new Cat();
  
        // Calling the nested class
        Animal.Type.animal();
        c.breed();
        c.sound();
    }
}

The animal is cat
Munchkin
Meow

Tipo 4: enumeración de Java 

Enum puede implementar cualquier interfaz en Java. Dado que enum es un tipo, similar a cualquier otra clase e interfaz, puede implementar cualquier interfaz en Java. Esto brinda mucha flexibilidad en algunos casos para usar Enum para implementar algún otro comportamiento.

Ejemplo

// Java Program illustrating Java Enum class
// implementing Interfaces
  
// Importing I/O classes
import java.io.*;
// interface class
interface Cat {
    public void breed();
}
  
// Class 1
// Enum class
enum Breed implements Cat {
  
    Siamese,
    Persian,
    Bengal,
    Burmese;
  
    public void breed()
    {
        System.out.print("The breed is " + this);
    }
}
  
// Class 2
// Main class
public class MainClass {
  
    // main driver method
    public static void main(String args[])
    {
        Breed.Persian.breed();
    }
}

The breed is Persian

Tipo 5: Proxy dinámico de Java

Un proxy llama al método del objeto indirectamente a través del objeto proxy. La API java.lang.reflect proporciona una clase como Proxy y una interfaz como InvocationHandler. Juntas, estas dos API crean una clase de proxy dinámica. La clase de proxy crea la clase de proxy dinámico sobre la base de parámetros dados. InvocationHandler invoca los métodos de la clase de proxy dinámico.

Ejemplo

// Java Program illustrating Java Dynamic Proxy Class
// implementing Interfaces
  
package javaInterface;
// Importing I/O classes
import java.io.*;
// Interface
interface Animal {
    public void breed();
    public void sound();
}
// Class 1
// Class implementing interface
class Cat implements Animal {
    public void breed() { System.out.println("Ragdoll"); }
    public void sound() { System.out.println("meow"); }
}
// Class 2
// InvocationHandler that simply passes every method call
// through to an instance:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
class LoggingHandler implements InvocationHandler {
    private final Object target;
    private Map<String, Integer> calls = new HashMap<>();
    public LoggingHandler(Object target)
    {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method,
                         Object[] args) throws Throwable
    {
        String name = method.getName();
        if (name.contains("toString")) {
            return calls.toString();
        }
        calls.merge(name, 1, Integer::sum);
        return method.invoke(target, args);
    }
}
// Class 3
// create a proxy using this invocation handler, we use the
// newProxyInstance
// static utility method on the java.reflection.Proxy class:
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
  
class MainClass {
    @SuppressWarnings("unchecked")
    public static <T> T withLogging(T target, Class<T> itf)
    {
        return (T)Proxy.newProxyInstance(
            itf.getClassLoader(), new Class<?>[] { itf },
            new LoggingHandler(target));
    }
    public static void main(String args[])
    {
        Cat c = new Cat();
        Animal logged = withLogging(c, Animal.class);
        logged.breed();
        logged.sound();
        System.out.println(logged);
    }
}

Producción:

Ragdoll
meow
{sound=1, breed=1}