Interfaces Java
1. Visão geral
Neste tutorial, vamos falar sobre interfaces em Java. Também veremos como Java os usa para implementar polimorfismo e várias heranças.
2. O que são interfaces em Java?
Em Java, uma interface é um tipo abstrato que contém uma coleção de métodos e variáveis constantes. É um dos principais conceitos em Java e éused to achieve abstraction, polymorphism and multiple inheritances.
Vejamos um exemplo simples de uma interface em Java:
public interface Electronic {
// Constant variable
String LED = "LED";
// Abstract method
int getElectricityUse();
// Static method
static boolean isEnergyEfficient(String electtronicType) {
if (electtronicType.equals(LED)) {
return true;
}
return false;
}
//Default method
default void printDescription() {
System.out.println("Electronic Description");
}
}Podemos implementar uma interface em uma classe Java usando a palavra-chaveimplements.
A seguir, vamos criar também uma classeComputer que implementa a interfaceElectronic que acabamos de criar:
public class Computer implements Electronic {
@Override
public int getElectricityUse() {
return 1000;
}
}2.1. Regras para criar interfaces
Em uma interface, temos permissão para usar:
Também devemos lembrar que:
-
não podemos instanciar interfaces diretamente
-
uma interface pode estar vazia, sem métodos ou variáveis nela
-
não podemos usar a palavrafinal na definição da interface, pois isso resultará em um erro do compilador
-
todas as declarações de interface devem terpublic ou modificador de acesso padrão; o modificadorabstract será adicionado automaticamente pelo compilador
-
um método de interface não pode serprivate,protected oufinal
-
as variáveis de interface sãopublic,static efinal por definição; não temos permissão para alterar sua visibilidade
3. O que podemos alcançar usando-os?
3.1. Funcionalidade Comportamental
Usamos interfaces para adicionar certas funcionalidades comportamentais que podem ser usadas por classes não relacionadas. Por exemplo,Comparable,Comparator eCloneable são interfaces Java que podem ser implementadas por classes não relacionadas. Abaixo está um exemplo da interfaceComparator que é usada para comparar duas instâncias do sclassEmployee :
public class Employee {
private double salary;
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
public class EmployeeSalaryComparator implements Comparator {
@Override
public int compare(Employee employeeA, Employee employeeB) {
if (employeeA.getSalary() < employeeB.getSalary()) {
return -1;
} else if (employeeA.getSalary() > employeeB.getSalary()) {
return 1;
} else {
return 0;
}
}
} Para obter mais informações, visite nosso tutorial emComparator and Comparable in Java.
3.2. Heranças Múltiplas
As classes Java suportam herança singular. No entanto, usando interfaces, também podemos implementar várias heranças.
Por exemplo, no exemplo abaixo, notamos que a classeCar implifica as interfacesFlyeTransform. Ao fazer isso, ele herda os métodosflyetransform:
public interface Transform {
void transform();
}
public interface Fly {
void fly();
}
public class Car implements Fly, Transform {
@Override
public void fly() {
System.out.println("I can Fly!!");
}
@Override
public void transform() {
System.out.println("I can Transform!!");
}
}3.3. Polimorfismo
Vamos começar fazendo a pergunta: o que épolymorphism? É a capacidade de um objeto assumir diferentes formas durante o tempo de execução. Para ser mais específico, é a execução do método de substituição que está relacionado a um tipo de objeto específico em tempo de execução.
In Java, we can achieve polymorphism using interfaces. Por exemplo, a interfaceShape pode assumir diferentes formas - pode serCircle ouSquare.
Vamos começar definindo a interfaceShape:
public interface Shape {
String name();
}Agora vamos criar também a classeCircle:
public class Circle implements Shape {
@Override
public String name() {
return "Circle";
}
}E também a classeSquare:
public class Square implements Shape {
@Override
public String name() {
return "Square";
}
}Finalmente, é hora de ver o polimorfismo em ação usando nossa interfaceShape e suas implementações. Vamos instanciar alguns objetosShape, adicioná-los a umList,e, finalmente, imprimir seus nomes em um loop:
List shapes = new ArrayList<>();
Shape circleShape = new Circle();
Shape squareShape = new Square();
shapes.add(circleShape);
shapes.add(squareShape);
for (Shape shape : shapes) {
System.out.println(shape.name());
} 4. Métodos padrão em interfaces
Interfaces tradicionais em Java 7 e anteriores não oferecem compatibilidade com versões anteriores.
O que isso significa é queif you have legacy code written in Java 7 or earlier, and you decide to add an abstract method to an existing interface, then all the classes that implement that interface must override the new abstract method. Caso contrário, o código será quebrado.
Java 8 solved this problem by introducing the default method que é opcional e pode ser implementado no nível da interface.
5. Regras de herança da interface
Para obter várias heranças através de interfaces, precisamos lembrar de algumas regras. Vamos examinar isso em detalhes.
5.1. Interface Estendendo Outra Interface
Quando uma interfaceextendsé outra interface, ela herda todos os métodos abstratos dessa interface. Vamos começar criando duas interfaces,HasColoreShape:
public interface HasColor {
String getColor();
}
public interface Box extends HasColor {
int getHeight()
}No exemplo acima,Box herda deHasColor usando a palavra-chaveextends. Ao fazer isso, a sinterfaceBox herdagetColor. Como resultado, a sinterfaceBox agora tem dois métodos:getColoregetHeight.
5.2. Classe abstrata implementando uma interface
Quando uma classe abstrata implementa uma interface, ela herda todos os seus métodos abstrato e padrão. Vamos considerar a interfaceTransform e a classeabstractVehicle que a implementa:
public interface Transform {
void transform();
default void printSpecs(){
System.out.println("Transform Specification");
}
}
public abstract class Vehicle implements Transform {}Neste exemplo, a classeVehicle herda dois métodos: o métodotransform abstrato e o métodoprintSpecs padrão.
6. Interfaces Funcionais
Java teve muitas interfaces funcionais desde seus primeiros dias, comoComparable (desde Java 1.2) eRunnable (desde Java 1.0).
Java 8 introduziu novas interfaces funcionais, comoPredicate,Consumer eFunction. Para saber mais sobre isso, visite nosso tutorial emFunctional Interfaces in Java 8.
7. Conclusão
Neste tutorial, fornecemos uma visão geral das interfaces Java e falamos sobre como usá-las para obter polimorfismo e várias heranças.
Como sempre, as amostras de código completas sãoavailable over on GitHub.