Aulas

Um guia prático para construir hierarquias de classes em Java: da abstração aos detalhes. Com exemplos de figuras, um mini‑editor, pagamentos e transporte, mostramos como extrair o comum para a classe base abstract, sobrescrever métodos como area()/ draw(), expandir o sistema sem reescrever código e evitar duplicação. Finalizamos com um panorama de erros típicos e dicas de projeto.

Vamos praticar o uso de abstrações em cenários reais: pagamentos, transporte, editor gráfico. Mostraremos como extrair o comportamento comum para uma classe base abstract, trabalhar por meio de um contrato comum e substituir o código “cheio de ramificações” de if- else por polimorfismo. No caminho, veremos como chamar de forma uniforme métodos como process(), move(), draw()/ resize(), para que o código seja flexível e extensível.

Como decompor aplicativos complexos em camadas de abstração (UI, lógica de negócios, acesso a dados) para que o código permaneça claro e extensível. Na prática, construímos um mini gerenciador de tarefas com as camadas Task, TaskRepository, TaskService, mostramos substituições de implementações e os benefícios para a equipe. Vamos analisar boas práticas, erros comuns e um exemplo com os serviços OrderService/ OrderRepository, bem como métodos como saveOrder() e findUserById().

Nesta aula, você aprenderá o que é uma interface em Java, como declará-la com a palavra-chave interface, como as classes implementam o contrato por meio de implements e por que, por padrão, os métodos são considerados public abstract. Vamos analisar as diferenças entre interface e classe, exemplos da JDK ( Comparable, Runnable, Serializable), um esquema visual e erros típicos.

Nesta aula, vamos comparar interfaces e classes abstratas em Java: quando escolher cada uma, em que elas diferem em termos de recursos e limitações, como são suas assinaturas ( abstract class e interface), o que significam modificadores como public, abstract, static, além de analisar exemplos da JDK, casos práticos e erros comuns (herança, implementação, uso de implements/ extends).

Nesta aula, analisamos como uma classe em Java pode implementar várias interfaces ao mesmo tempo: a sintaxe com a palavra-chave implements, a combinação de papéis (por exemplo, Movable, Attackable, Serializable), assinaturas de métodos iguais, a ausência do “diamante da morte” e também o que fazer em caso de conflitos de métodos default. Traz exemplos práticos e análise de erros comuns.

Nesta aula, analisamos o que é uma interface funcional (exatamente um método abstrato), como e por que marcá-la com a anotação @FunctionalInterface, com o que é permitido complementar a interface por meio de métodos default e static, e também como aplicar tais interfaces na prática (classes comuns e classes anônimas). Exemplos com Runnable, Comparator<T> e interfaces de java.util.function são acompanhados por uma tabela e pela análise de erros típicos.

Como interfaces transformam código em uma arquitetura flexível: programamos contra abstrações, injetamos dependências via DI, substituímos implementações em testes, adicionamos novos comportamentos sem alterar o núcleo ( OCP). Examinamos como interfaces estão na base dos padrões Observer, Strategy, Command, e mostramos a prática com exemplos ( UserRepository, NotificationSender, estratégias de pagamento).

Nesta aula, vamos explorar as expressões lambda em Java: o que são e para que servem, como funciona a sintaxe e as simplificações, como as lambdas se relacionam com interfaces funcionais ( @FunctionalInterface), em que elas diferem de classes anônimas e como funciona a captura de variáveis ( final / effectively final). Com exemplos práticos usando Runnable, Consumer, Comparator, Function e a Stream API, veremos como escrever de forma mais curta e clara. Terminaremos com a seção “Erros comuns” e dicas de como evitá-los.

Guia rápido sobre referências a métodos em Java: onde e como usar method reference em vez de lambdas. Vamos analisar 4 formas: Class::method (estático e “de instância”), object::method, Class::new. Vamos entender o mapeamento de assinaturas para interfaces funcionais, comparar com expressões lambda, ver exemplos práticos com forEach, sort, map e discutir erros típicos (incompatibilidade de assinaturas, sobrecarga de métodos etc.).

Nesta aula analisamos por que no Java 8 surgiram os métodos default em interfaces, como eles permitem evoluir o API sem quebrar código legado, sua sintaxe (a palavra‑chave default antes do tipo de retorno) e o comportamento nas implementações. Com exemplos da biblioteca padrão ( List: forEach, replaceAll, sort) veremos a prática de uso. Vamos discutir limitações: não é possível sobrescrever métodos de Object ( equals/ hashCode/ toString), além das regras de resolução de conflitos na implementação múltipla e erros comuns.

Vamos entender como e por que as interfaces em Java passaram a ter static-métodos: sintaxe de declaração, diferença em relação aos default-métodos, principais restrições (não são herdados, não podem ser sobrescritos, chamada apenas pelo nome da interface, acesso somente a membros static, suporte a private static a partir do Java 9+). Na prática, veremos Movable.resetPosition(), um Logger auxiliar, as fábricas de coleções List.of()/ Set.of()/ Map.of() e utilitários como Comparator.reverseOrder(). No final — erros típicos e como evitá-los.