Desbravando SOLID (eBook)

Práticas avançadas para códigos de qualidade em Java moderno

Alexandre Aquiles (Autor)

eBook Download: EPUB

2022
444 Seiten
Casa do Código (Verlag)
978-85-5519-310-1 (ISBN)

Infos

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.

Autor

Alexandre Aquiles é Engenheiro de Computação pela Unicamp. Desenvolve software há mais de 15 anos, tendo trabalhado nas áreas de logística, governo, mineração e seguros. Há mais de 8 anos, ajuda as pessoas a prosperarem através da Educação em Tecnologia. É especialista em Java e Design de código, mas se aventura por outras áreas.

Inhalt

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

Produkt-Details

• Erscheint lt. Verlag: 2.8.2022
• Verlagsort: São Paulo
• Sprache: portugiesisch
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• Schlagworte: Desenvolvimento de Software • Java • Orientação a Objetos • Programação
• ISBN-10: 85-5519-310-9 / 8555193109
• ISBN-13: 978-85-5519-310-1 / 9788555193101