Devido ao COVID-19, para proteger a todos os envolvidos na gráfica, correio, na Casa do Código e você, estamos temporariamente vendendo apenas e-books.

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

Orientação a Objetos e SOLID para Ninjas Projetando classes flexíveis

Mauricio Aniche

Conteúdo

Todo profissional que trabalha com desenvolvimento deve conhecer os conceitos básicos de Orientação a Objetos. Esse paradigma, além de fundamental, é utilizado em todo o mercado de software ao redor do mundo. Mas nós sabemos que, na prática, o que vemos espalhado por aí são pilhas de códigos procedurais disfarçados.

Neste livro, Maurício Aniche discute como a implementação e o foco no projeto de classes é importante para criar um software de qualidade. Sempre mantendo a característica de escrever um livro com uma didática voltada para o mundo real, você vai entender como moldar e dominar as peças da Orientação a Objetos usando os princípios de SOLID e escrevendo um código mais elegante e fácil de manter. Saia do básico e vire um ninja da Orientação a Objetos aprendendo de forma prática e eficaz as boas práticas do assunto.

Os exemplos ao longo do livro estão escritos em Java, porém são facilmente compreendidas por qualquer programador. As discussões fazem sentido para todas as linguagens OO.

 

Sumário

  • 1 - Orientação a Objetos, pra que te quero?
  • 1.1 - Qual o público deste livro?
  • 2 - A coesão e o tal do SRP
  • 2.1 - Um exemplo de classe não coesa
  • 2.2 - Qual o problema dela?
  • 2.3 - Em busca da coesão
  • 2.4 - Uma pitada de encapsulamento
  • 2.5 - Quando usar métodos privados?
  • 2.6 - Falta de coesão em controllers
  • 2.7 - Inveja da outra classe
  • 2.8 - SRP ─ Single Responsibility Principle
  • 2.9 - Separação do modelo, infraestrutura, e a tal da arquitetura hexagonal
  • 2.10 - Conclusão
  • 3 - Acoplamento e o tal do DIP
  • 3.1 - Qual o problema dela?
  • 3.2 - Estabilidade de classes
  • 3.3 - Buscando por classes estáveis
  • 3.4 - DIP ─ Dependency Inversion Principle
  • 3.5 - Um outro exemplo de acoplamento
  • 3.6 - Dependências lógicas
  • 3.7 - Conclusão
  • 4 - Classes abertas e o tal do OCP
  • 4.1 - Qual o problema dela?
  • 4.2 - OCP ─ Princípio do Aberto-Fechado
  • 4.3 - Classes extensíveis
  • 4.4 - A testabilidade agradece!
  • 4.5 - Um exemplo real
  • 4.6 - Ensinando abstrações desde a base
  • 4.7 - Conclusão
  • 5 - O encapsulamento e a propagação de mudanças
  • 5.1 - Qual o problema dela?
  • 5.2 - Intimidade inapropriada
  • 5.3 - Um sistema OO é um quebra-cabeças
  • 5.4 - Tell, Don't Ask
  • 5.5 - Procurando por encapsulamentos problemáticos
  • 5.6 - A famosa Lei de Demeter
  • 5.7 - Getters e setters pra tudo, não!
  • 5.8 - Corrigindo o código inicial
  • 5.9 - Modelos anêmicos
  • 5.10 - Conclusão
  • 6 - Herança x composição e o tal do LSP
  • 6.1 - Qual o problema dela?
  • 6.2 - LSP ─ Liskov Substitutive Principle
  • 6.3 - O exemplo do quadrado e retângulo
  • 6.4 - Acoplamento entre a classe pai e a classe filho
  • 6.5 - Favoreça a composição
  • 6.6 - Herança para DSLs e afins
  • 6.7 - Quando usar herança então?
  • 6.8 - Pacotes: como usá-los?
  • 6.9 - Conclusão
  • 7 - Interfaces magras e o tal do ISP
  • 7.1 - Interfaces coesas e magras
  • 7.2 - Pensando na interface mais magra possível
  • 7.3 - E os tais dos repositórios do DDD?
  • 7.4 - Fábricas ou injeção de dependência?
  • 7.5 - Conclusão
  • 8 - Consistência, objetinhos e objetões
  • 8.1 - Construtores ricos
  • 8.2 - Validando dados
  • 8.3 - Teorema do bom vizinho e nulos para lá e para cá
  • 8.4 - Tiny Types é uma boa ideia?
  • 8.5 - DTOs do bem
  • 8.6 - Imutabilidade x mutabilidade
  • 8.7 - Classes que são feias por natureza
  • 8.8 - Nomenclatura de métodos e variáveis
  • 8.9 - Conclusão
  • 9 - Maus cheiros de design
  • 9.1 - Refused Bequest
  • 9.2 - Feature Envy
  • 9.3 - Intimidade inapropriada
  • 9.4 - God Class
  • 9.5 - Divergent Changes
  • 9.6 - Shotgun Surgery
  • 9.7 - Entre outros
  • 10 - Métricas de código
  • 10.1 - Complexidade ciclomática
  • 10.2 - Tamanho de métodos
  • 10.3 - Coesão e a LCOM
  • 10.4 - Acoplamento aferente e eferente
  • 10.5 - Má nomenclatura
  • 10.6 - Como avaliar os números encontrados?
  • 10.7 - Ferramentas
  • 11 - Conclusão
  • 11.1 - Onde posso ler mais sobre isso?
  • 11.2 - Obrigado!

veja mais detalhes

Autor

Mauricio Aniche

Maurício é instrutor e desenvolvedor da Caelum, possui mais de 9 anos de experiência de desenvolvimento de softwares, tendo participado de projetos para grandes empresas nacionais e internacionais. Mauricio é também mestre em Ciência da Computação pela Universidade de São Paulo (USP), onde pesquisa sobre TDD e sua influência no design de sistemas orientados a objetos. Atualmente, é aluno de doutorado pelo mesmo instituto. Palestrante em eventos nacionais e internacionais, com destaque para sua apresentação no 1º Workshop Internacional sobre Test-Driven Development, localizado em Paris, no ano de 2010, Agile Brazil 2010, 2011 e 2012, e QCON SP 2010 e 2012. Mauricio gosta de discutir sobre TDD, melhores práticas e princípios de orientação a objetos, métodos ágeis de desenvolvimento de software e linguagens de programação. Está no Twitter como @mauricioaniche .

Dados do produto

Número de páginas:
155
ISBN:
978-85-5519-037-7

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter