Conteúdo

Você já aprendeu a programar e certamente já ouviu falar em Orientação a Objetos e seus conceitos como classes, objetos, métodos, interfaces, herança, polimorfismo. Mas você sabe, efetivamente, quando e como aplicar tudo isso? Ao trabalhar com programação, é clara a necessidade de organizar nosso código para que ele seja fácil de entender e manter, otimizando sua leitura e minimizando o impacto de eventuais mudanças.

Neste livro, Alexandre Aquiles mostra práticas de design e arquitetura para você organizar seu código através dos princípios SOLID. Você verá tópicos avançados da Orientação a Objetos, com bons e maus exemplos de aplicação dos conceitos, para aprender como realmente tirar o melhor proveito das técnicas e saber tomar decisões para cada contexto. Através de plugins e módulos Maven e JPMS, chegaremos a uma Arquitetura Hexagonal. Tudo isso, demonstrado em uma aplicação real e com acesso a vídeos com o passo a passo dos códigos.

Saiba o que você vai aprender

Sumário

• 1 Para que serve Orientação a Objetos?
• 1.1 Modelagem e dependências
• 1.2 Os princípios SOLID
• 1.3 Os princípios de coesão e acoplamento de módulos

• 2 Conhecendo o Cotuba
• 2.1 Usando o Cotuba
• 2.2 Um pouco sobre a implementação do Cotuba
• 2.3 Gerando um ebook
• 2.4 O código do Cotuba

• 3 Princípio da Responsabilidade Única (SRP): classes coesas
• 3.1 O Princípio da Responsabilidade Única (SRP)
• 3.2 SRP e classes coesas
• 3.3 Responsabilidades e SRP no Cotuba
• 3.4 Não se repita
• 3.5 Um domain model simples
• 3.6 MVC, entidades e casos de uso
• 3.7 Responsabilidades em pacotes e métodos
• 3.8 Contraponto: críticas ao SRP
• 3.9 O que aprendemos?

• 4 Princípio da Inversão de Dependências (DIP): dependências estáveis
• 4.1 Acoplamento, estabilidade e volatilidade
• 4.2 Abstrações e inversão das dependências
• 4.3 Regras de negócio x detalhes
• 4.4 Código de alto nível e baixo nível
• 4.5 O Princípio da Inversão de Dependências (DIP)
• 4.6 DIP no Cotuba
• 4.7 Design Pattern: Factory
• 4.8 Melhorando o nome das implementações
• 4.9 Abstrações mais perto de quem as utiliza
• 4.10 Uma classe para os parâmetros
• 4.11 Contraponto: críticas ao DIP
• 4.12 O que aprendemos?

• 5 Princípio Aberto/Fechado (OCP): objetos flexíveis
• 5.1 Em busca da abstração perfeita
• 5.2 Design Pattern: Command
• 5.3 O Princípio Aberto/Fechado (OCP)
• 5.4 Design Pattern: Strategy
• 5.5 Revisitando abstrações
• 5.6 Uma Factory inteligente
• 5.7 Das condicionais ao polimorfismo
• 5.8 Pondo a flexibilidade do Cotuba à prova
• 5.9 Contraponto: críticas ao OCP
• 5.10 O que aprendemos?

• 6 OCP potencializado: plugins
• 6.1 Um plugin no Cotuba
• 6.2 Aplicando temas CSS nos capítulos
• 6.3 Ligando os pontos (de extensão) com a Service Loader API
• 6.4 Alguns usos da Service Loader API na plataforma Java
• 6.5 Um plugin para calcular estatísticas do ebook
• 6.6 O que aprendemos?

• 7 Princípio de Substituição de Liskov (LSP): herança do jeito certo
• 7.1 Continuando a implementação das estatísticas
• 7.2 Contando palavras
• 7.3 Herdando inutilidades
• 7.4 O Princípio da Substituição de Liskov (LSP)
• 7.5 Favorecendo composição à herança
• 7.6 Qual a necessidade de um método se não há nada para ser feito?
• 7.7 Contraponto: críticas ao LSP
• 7.8 O que aprendemos?

• 8 Princípio da Segregação de Interfaces (ISP): clientes separados, interfaces separadas
• 8.1 O Princípio da Segregação de Interfaces (ISP)
• 8.2 Separando classes, não apenas interfaces
• 8.3 Interfaces específicas para o cliente no Cotuba
• 8.4 Contraponto: críticas ao ISP
• 8.5 O que aprendemos?

• 9 Um pouco de imutabilidade e encapsulamento
• 9.1 Em direção à imutabilidade
• 9.2 Um domain model imutável
• 9.3 Design Pattern: Builder
• 9.4 Voltando atrás na segregação de interfaces
• 9.5 Favorecendo imutabilidade com Records
• 9.6 Encapsulamento
• 9.7 Design Pattern: Iterator
• 9.8 O que aprendemos?

• 10 Princípios de Coesão e Acoplamento de Módulos
• 10.1 O que são módulos?
• 10.2 Princípios de coesão de módulos
• 10.3 Modularizando o Cotuba
• 10.4 Módulos Maven
• 10.5 Princípios de acoplamento de módulos
• 10.6 Quebrando ciclos no Cotuba
• 10.7 O que aprendemos?

• 11 Além da linha de comando: o Cotuba Web
• 11.1 Gerando ebooks pela Web
• 11.2 Quando nosso design não antecipa as mudanças
• 11.3 O que aprendemos?

• 12 Módulos com o Java Platform Module System (JPMS)
• 12.1 Encapsulamento de módulos e o Classpath
• 12.2 JPMS, um sistema de módulos para o Java
• 12.3 Módulos JPMS no Cotuba
• 12.4 Módulos automáticos do JPMS
• 12.5 Service Loader API com JPMS
• 12.6 O Modulepath
• 12.7 JPMS e o Spring Boot
• 12.8 O que aprendemos?

• 13 Arquitetura Hexagonal: uma arquitetura centrada no domínio
• 13.1 Hexágonos (ou Conectores & Adaptadores)
• 13.2 Arquitetura Hexagonal no Cotuba
• 13.3 Arquitetura de Plugins
• 13.4 Barreiras arquiteturais
• 13.5 Clean Architecture
• 13.6 Contraponto
• 13.7 Conclusão

• 14 Apêndice: O código inicial do Cotuba

• 15 Apêndice: Referências