Prefácio por João Júnior

Este livro é único, essencial e prático!

Toda leitura é um diálogo entre o leitor e o autor do livro. Quando o livro é sobre um assunto técnico, além do diálogo, eu acredito que devemos fazer um debate com o autor. Para quem tem o privilégio de conhecer o Alexandre, a leitura deste livro é exatamente como um debate com ele. Não apenas respostas simplórias são dadas, mas o contexto de cada decisão, além dos contrapontos, quando necessário, são apresentados pelo autor.

Logo após aprendermos a programar, nos primeiros anos de nossa carreira, emerge a necessidade de organizar o nosso código para ser fácil de entender, ler e manter. Este livro visa ensinar formas e conceitos de como fazer isso, através de Orientação a Objetos e SOLID.

Se você é um desenvolvedor ou uma desenvolvedora sem muita experiência, você verá os fundamentos de Orientação a Objetos: encapsulamento, polimorfismo, herança e composição. Além disso, você será exposto(a) a bons e maus exemplos de uso desses conceitos. Isso será um grande diferencial na sua carreira, e é muito difícil encontrar materiais sobre esses conceitos tão bem descritos e aplicados em exemplos reais.

Por outro lado, se você é experiente, você vai aprender como usar Orientação a Objetos e diversas técnicas e conceitos para simplificar o código do seu projeto. Você vai não apenas aprender conceitos de forma isolada, mas também será guiado(a) a como tomar decisões sobre como e quando usar esses conceitos. Você também vai aprender sobre quando não deve usar muitos dos conceitos e técnicas apresentados aqui.

Embora os exemplos apresentados sejam na linguagem Java, este livro é essencial para desenvolvedores de todas as linguagens. Se você programa em Java, poderá aplicar os exemplos diretamente em seus códigos. E se você utiliza outra linguagem de programação, não será muito difícil adaptar o que aprendeu aqui.

Além de todo o conhecimento apresentado, um grande diferencial é que ele usa todos os conceitos e técnicas apresentados em uma aplicação real. Então, você vai começar com um código que já está em produção e, à medida que passar pelos capítulos, vai refatorar o código para torná-lo mais legível e extensível. Essa é uma das características que torna este livro único, essencial e prático. O autor também nos presenteia com inúmeras referências para continuarmos nossos estudos.

Então, tenha um excelente debate!

João Júnior, Tech Lead na Shopify

Sobre o livro

Este livro é a adaptação do curso "Práticas de Design e Arquitetura de Código" da Caelum, criado pelo autor em 2018 e ministrado para centenas de alunos e alunas desde então.

No decorrer do livro, vamos melhorar o código do Cotuba, uma aplicação que gera e-books nos formatos PDF e EPUB a partir de arquivos Markdown, e também adicionaremos algumas funcionalidades à aplicação.

À medida que formos refatorando e adicionando funcionalidades ao Cotuba, estudaremos assuntos avançados de Orientação a Objetos.

O capítulo 1 apresenta uma contextualização dos princípios SOLID em relação a outras técnicas.

No capítulo 2, conheceremos o código inicial do Cotuba, que será refatorado nos capítulos posteriores.

No capítulo 3, estudaremos o Single Responsibility Principle (Princípio da Responsabilidade Única), aplicando-o ao Cotuba.

No capítulo 4, abordaremos o Dependency Inversion Principle (Princípio da Inversão das Dependências) e o design pattern Factory.

No capítulo 5, é a vez de estudarmos o Open/Closed Principle (Princípio do Aberto/Fechado) e os design patterns Command e Strategy.

No capítulo 6, criaremos plugins com a Service Loader API, estudando um caso extremo do Open/Closed Principle.

No capítulo 7, corrigiremos violações do Liskov Substitution Principle (Princípio de Substituição de Liskov) no Cotuba.

No capítulo 8, vamos explorar o Interface Segregation Principle (Princípio da Segregação de Interfaces).

O capítulo 9 trata de assuntos importantes em Orientação a Objetos como imutabilidade e encapsulamento, além de implementar os design patterns Builder e Iterator.

No capítulo 10, discutiremos sobre modularização, abordando os princípios de Coesão e Acoplamento de módulos e implementando módulos Maven.

No capítulo 11, verificaremos a flexibilidade do design de código do Cotuba, utilizando-o em uma aplicação Web e ajustando alguns detalhes.

No capítulo 12, veremos como usar o Java Platform Module System (JPMS), disponível a partir do Java 9, para reforçar o encapsulamento dos módulos do Cotuba.

No capítulo 13, definiremos o que é uma Arquitetura Hexagonal e como o código refatorado do Cotuba se encaixa nesse estilo arquitetural.

Ao final de cada capítulo, haverá um QR Code de um vídeo que demonstra o passo a passo de código. Além disso, teremos um apêndice com o código inicial do Cotuba e outro com as referências bibliográficas.

Para quem é o livro

Este livro é focado em desenvolvedores e desenvolvedoras familiarizados com a linguagem Java e com os fundamentos da Orientação de Objetos, como classes, objetos, atributos, métodos, herança, polimorfismo, interfaces e que desejam estudar técnicas avançadas de design de código.

Neste livro, vamos utilizar recursos do Java 17. É recomendada a utilização de uma IDE, como IntelliJ ou Eclipse, para seguir os exemplos do livro. Além disso, utilizaremos a ferramenta Maven, na versão 3.8 ou posterior.

Nos exemplos de linha de comando, utilizaremos comandos disponíveis em um Unix como qualquer distribuição Linux ou MacOS. Para executá-los em uma máquina Windows, utilize ferramentas como WSL, Cygwin ou Git Bash. Além disso, não deixe de instalar programas leitores de PDFs e EPUBs!

Sobre o autor

Alexandre Aquiles é Engenheiro de Software desde 2005, tendo desenvolvido software para indústrias como Logística, Governo, Mineração, Seguros e Educação. Acredita que softwares devem ser desenvolvidos de forma iterativa e incremental, entregando continuamente código de valor e com qualidade. Especializado na plataforma Java, tem mais de 6500 horas como instrutor de cursos sobre Orientação a Objetos, Arquitetura de Software, Testes Automatizados e TDD, Integração de Sistemas e Microsserviços. É coautor do livro Controlando versões com Git e GitHub publicado em 2014 pela Casa do Código.