Interfaces

"Olá, amigo! Hoje você vai fazer algumas descobertas. O assunto de hoje — rufar de tambores, por favor — são as interfaces. "

"Sim. Um dia tão maravilhoso que estou indo para casa tomar um banho."

" Uma interface é filha de Abstração e Polimorfismo. A interface é muito parecida com uma classe abstrata onde todos os métodos são abstratos. Ela é declarada da mesma forma que uma classe, mas com a palavra-chave . Aqui estão alguns exemplos: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Interessante. Mas por que precisamos de interfaces? Quando elas são usadas?"

"As interfaces têm duas grandes vantagens sobre as classes:"

1) Separação de "definições de método" de implementações de método.

Eu disse anteriormente que, se você quiser permitir que outras classes chamem os métodos de sua classe, será necessário marcá-los comopublic . Se você deseja que determinados métodos sejam chamados apenas de sua própria classe, eles devem ser marcados private. Em outras palavras, estamos dividindo os métodos da classe em duas categorias: «para todos» e «só para mim».

Podemos usar interfaces para fortalecer ainda mais essa separação. Faremos uma "aula para todos" especial que herdará uma segunda "aula só para mim". Isso ficaria mais ou menos assim:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Dividimos nossa classe em duas partes: uma interface e uma classe que implementa a interface.

"Então, qual é a vantagem?"

"A mesma interface pode ser implementada por (herdar) classes diferentes. E cada classe pode ter seu próprio comportamento. Assim como ArrayList e LinkedList são duas implementações diferentes da interface List. "

Assim, estamos ocultando não apenas as diferentes implementações, mas também as classes que contêm as implementações (podemos apenas usar interfaces em qualquer lugar do código). Isso nos permite substituir com muita flexibilidade alguns objetos por outros objetos enquanto o programa está em execução, alterando o comportamento de um objeto sem o conhecimento de nenhuma das classes que o utilizam.

Em combinação com o polimorfismo, esta é uma técnica muito poderosa. No momento, está longe de ser óbvio por que precisaríamos fazer isso. Você deve primeiro encontrar programas que consistem em dezenas ou centenas de classes para apreciar como as interfaces podem simplificar muito sua vida.

2) Herança múltipla.

Em Java, cada classe pode ter apenas uma classe pai. Em outras linguagens de programação, as classes geralmente podem ter várias classes pai. Isso é muito conveniente, mas também cria muitos problemas.

Java oferece um compromisso:   você não pode herdar várias classes, mas pode implementar várias interfaces. Uma interface pode ter várias interfaces pai.  Uma classe pode implementar várias interfaces e herdar apenas uma classe pai.