Interfaces na prática
Use interfaces como tipos, passe-as para métodos e troque implementações facilmente. Pratique pequenos padrões para criar código flexível.
Interfaces na prática é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 3 aulas no total.
Visão geral
Interfaces na prática: trate capacidades como tipos e mantenha o código chamador independente das classes concretas. Você pode passar uma interface para um método, armazená-la em uma lista e substituí-la por outra implementação quando necessário.
Interface como parâmetro
Os métodos ganham flexibilidade quando recebem o tipo interface como parâmetro:
- O código chamador permanece inalterado.
- Diferentes classes podem aplicar o mesmo contrato e ser utilizadas.
- Em um teste, você pode inserir um objeto falso ou um dublê e fazer experimentos rapidamente.
Código: capacidade Printable
O método usa o contrato Printable, não a classe concreta; mesmo que as implementações mudem, o código chamador permanece igual.
public class Main {
// 1) Define a tiny capability
static interface Printable { void print(); }
// 2) Two implementations
static class TextDoc implements Printable {
public void print() { System.out.println("[TextDoc] Printing text pages"); }
}
static class Photo implements Printable {
public void print() { System.out.println("[Photo] Printing a photo"); }
}
// 3) A method that depends on capability, not class
static void runJob(Printable p) {
p.print(); // caller does not care which class it is
}
public static void main(String[] args) {
runJob(new TextDoc());
runJob(new Photo());
}
}
Interface como tipo de retorno
Às vezes, um método de fábrica retorna uma interface. O código chamador vê apenas as capacidades e não precisa conhecer a classe real. Isso reduz o acoplamento e aumenta a modularidade.
Código: estratégia com Formatter
O mesmo método funciona com diferentes implementações de Formatter. Conseguimos mudar o comportamento sem alterar a classe.
public class Main {
// Strategy: different ways to format text
static interface Formatter { String format(String s); }
static class UpperFormatter implements Formatter {
public String format(String s) { return s.toUpperCase(); }
}
static class LowerFormatter implements Formatter {
public String format(String s) { return s.toLowerCase(); }
}
// Uses any Formatter
static String show(String title, Formatter f) {
return title + " -> " + f.format(title);
}
public static void main(String[] args) {
System.out.println(show("Hello", new UpperFormatter()));
System.out.println(show("Hello", new LowerFormatter()));
}
}
Código: lista de interfaces
Uma matriz ou lista pode ser do tipo de uma interface. O laço faz uma chamada uniforme; cada elemento executa sua própria implementação.
public class Main {
static interface Task { void run(); }
static class EmailTask implements Task { public void run(){ System.out.println("Send email"); } }
static class ReportTask implements Task { public void run(){ System.out.println("Generate report"); } }
static class CleanupTask implements Task { public void run(){ System.out.println("Clean temp files"); } }
public static void main(String[] args) {
Task[] queue = { new EmailTask(), new ReportTask(), new CleanupTask() };
for (int i = 0; i < queue.length; i = i + 1) {
queue[i].run(); // same call, different behavior
}
}
}
Verificação prática de interfaces
Verificação rápida: por que é útil "programar para uma interface"?
Recapitulação
Recapitulação: usar um tipo de interface em parâmetros, valores de retorno e coleções torna o código flexível. Você pode trocar as implementações e experimentar rapidamente com objetos simulados nos testes.
Perguntas Frequentes
A aula “Interfaces na prática” é grátis?
Sim — o texto completo de “Interfaces na prática” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 3 aulas no total.
O que vou aprender em “Interfaces na prática”?
Use interfaces como tipos, passe-as para métodos e troque implementações facilmente. Pratique pequenos padrões para criar código flexível. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.
Quanto tempo leva a aula “Interfaces na prática”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Interfaces na prática
- Noções básicas de genéricos (T, inferência)
- Métodos e classes genéricos