Casa do Código - Livros e Tecnologia

  • Programação
  • Lógica
  • Java
  • .NET
  • PHP
  • Games
  • OO
  • Funcional
  • Python
  • Outros
  • Todos
  • Mobile
  • iOS
  • Android
  • Multiplataforma
  • Outros
  • Todos
  • Front-end
  • HTML e CSS
  • JavaScript
  • Outros
  • Todos
  • Infraestrutura
  • Web
  • Dados
  • Outros
  • Todos
  • Business
  • Startups
  • Marketing Digital
  • Gestão
  • Agile
  • Outros
  • Todos
  • Design & UX
  • Você tem 0 itens na sacola 0 Abrir navegação por categorias e busca Ir para ao topo da página

    Use o código e tenha 10% de desconto!

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

    Alexandre Aquiles
    Livro Desbravando SOLID

    *Você terá acesso às futuras atualizações do livro.

    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.

    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

    Dados do produto

    Número de páginas:
    444
    ISBN:
    978-85-5519-309-5
    Data publicação:
    08/2022
    Fórum de discussões

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter

    *Você terá acesso às futuras atualizações do livro.

    altLogoFooter

    Uma empresa do Grupo Alun

    Logo da Alun

    Links da
    Casa do Código

    • Meus ebooks
    • Sobre a Casa do Código
    • Todos os livros
    • Nossas coleções
    • Quero escrever um livro ou fazer parceria
    • Perguntas Frequentes
    • Política de Privacidade
    • Fale conosco

    Nas redes sociais

    • /CasaDoCodigo
    • @casadocodigo
    • @casadocodigo

    Receba novidades e lançamentos

    Este site aceita Pix, Cartão de Crédito, Débito

    • pagarme
    • paypal

    Grupo Alun

    • Educação em Tecnologia

      • FIAP
      • Casa do Código
      • PM3 - Cursos de Produto
    • Mais Alura

      • Alura Start
      • Alura Língua
      • Alura Para Empresas
      • Alura LATAM
    • Comunidade

      • Tech Guide
      • 7 days of code
      • Hipsters ponto Jobs
    • Podcasts

      • Hipsters ponto Tech
      • Dev sem Fronteiras
      • Layers ponto Tech
      • Like a Boss
      • Scuba Dev