Introdução
A interface é um recurso muito utilizado em Java, bem como na maioria das linguagens orientadas a objeto, para “obrigar” a um determinado grupo de classes a ter métodos ou propriedades em comum para existir em um determinado contexto, contudo os métodos podem ser implementados em cada classe de uma maneira diferente. Pode-se dizer, a grosso modo, que uma interface é um contrato que quando assumido por uma classe deve ser implementado.
Utilizando interface em Java
Dentro das interfaces existem somente assinaturas de métodos e propriedades, cabendo à classe que a utilizará realizar a implementação das assinaturas, dando comportamentos práticos aos métodos.
Abaixo é possível ver um exemplo de uma interface chamada FiguraGeometrica com três assinaturas de métodos que virão a ser implementados pelas classes referentes às figuras geométricas.
Listagem 1: Interface FiguraGeometrica
public interface FiguraGeometrica
{
public String getNomeFigura();
public int getArea();
public int getPerimetro();
}Para realizar a chamada/referência a uma interface por uma determinada classe, é necessário adicionar a palavra-chave implements ao final da assinatura da classe que irá implementar a interface escolhida.
Sintaxe:
public class nome_classe implements nome_interface
Onde:
- nome_classe – Nome da classe a ser implementada.
- nome_Interface – Nome da interface a se implementada pela classe.
Abaixo é possível ver duas classes que implementam a interface FiguraGeometrica, uma chamada Quadrado e outra Triangulo.
Listagem 2: Classe Quadrado
/**
*
* @author Robson Fernando Gomes
*/
public class Quadrado implements FiguraGeometrica {
private int lado;
public int getLado() {
return lado;
}
public void setLado(int lado) {
this.lado = lado;
}
@Override
public int getArea() {
int area = 0;
area = lado * lado;
return area;
}
@Override
public int getPerimetro() {
int perimetro = 0;
perimetro = lado * 4;
return perimetro;
}
@Override
public String getNomeFigura() {
return "quadrado";
}
}Listagem 3: Classe Triangulo
/**
*
* @author Robson Fernando Gomes
*/
public class Triangulo implements FiguraGeometrica {
private int base;
private int altura;
private int ladoA;
private int ladoB;
private int ladoC;
public int getAltura() {
return altura;
}
public void setAltura(int altura) {
this.altura = altura;
}
public int getBase() {
return base;
}
public void setBase(int base) {
this.base = base;
}
public int getLadoA() {
return ladoA;
}
public void setLadoA(int ladoA) {
this.ladoA = ladoA;
}
public int getLadoB() {
return ladoB;
}
public void setLadoB(int ladoB) {
this.ladoB = ladoB;
}
public int getLadoC() {
return ladoC;
}
public void setLadoC(int ladoC) {
this.ladoC = ladoC;
}
@Override
public String getNomeFigura() {
return "Triangulo";
}
@Override
public int getArea() {
int area = 0;
area = (base * altura) / 2;
return area;
}
@Override
public int getPerimetro() {
int perimetro = 0;
perimetro = ladoA + ladoB + ladoC;
return perimetro;
}
}Como é possível ver acima, ambas as classes seguiram o contrato da interface FiguraGeometrica, porém cada uma delas a implementou de maneira diferente.
Ao contrário da herança que limita uma classe a herdar somente uma classe pai por vez, é possível que uma classe implemente varias interfaces ao mesmo tempo.
Imagine, por exemplo, uma interface chamada Veiculo e outra chamada Motor.
Listagem 4: Interface Veiculo
/**
*
* @author Robson Fernando Gomes
*/
public interface Veiculo {
public String getNome();
public String getId();
}Listagem 5: Interface Motor
/**
*
* @author Robson Fernando Gomes
*/
public interface Motor {
public String getModelo();
public String getFabricante();
}A seguir é possível visualizar a implementação das interfaces em uma classe chamada Carro.
Listagem 6: Clase Carro
/**
*
* @author Robson Fernando Gomes
*/
public class Carro implements Veiculo,Motor{
@Override
public String getId() {
}
@Override
public String getNome() {
}
@Override
public String getFabricante() {
}
@Override
public String getModelo() {
}
}
}Conclusão
Por fim, interface nada mais que uma espécie de contrato de regras que uma classes deve seguir em um determinado contexto. Como em Java não existe herança múltipla, a interface passa a ser uma alternativa.
Espero que este conteúdo, apesar de breve, possa ser útil principalmente para aqueles que estão iniciando os estudos em Java e Orientação a Objetos.
Até a próxima.
