O documento apresenta 9 regras para melhorar o código orientado a objetos, conhecidas como Object Calisthenics, focadas em conceitos como baixo acoplamento, encapsulamento e testabilidade. As regras incluem limitar níveis de indentação, evitar else, encapsular tipos primitivos e getter/setters, e manter classes e métodos pequenos e focados.

1. Object Calisthenics:
9 regras para melhorar seu código

2. Olá!
Me chamo Jéssica
Programadora na RD, host do PodProgramar e mentora
Meus contatinhos em: jessicazanelato.dev
2

3. Object?
= Programação Orientada a Objetos
3

4. Calisthenics?
= origem na palavra grega 'exercício'
4

5. Origem
Jeff Bay em 2009
5

6. Por que é
importante?
Porque continuamos a escrever código difícil
de entender, testar e manter
6

7. Conceitos por trás do bom design de
código:
● Coesão
● Baixo acoplamento
● Sem redudância
● Encapsulamento
● Testabilidade
● Legibilidade
● Foco
7

8. Apenas um nível de
indentação por método
1

9. Problemas:
● Baixa coesão
● Menor legibilidade
● Dificuldade em dar manutenção
● Dificuldade em testar
9

10. class Customer {
public function getPromoCode(string $promoName) {
// 1
if ($this->promoCode) {
// 2
if (false === $this->promoCodeExpired()) {
// 3
if ($this->promoName == $promoName) {
return $this->promoCode;
} else {
throw new Exception('Promoção não existe mais');
}
} else {
throw new Exception('Promoção Expirada');
}
} else {
throw new Exception('Cliente sem código de promoção');
}
}
}
10

11. class Customer {
public function getPromoCode(string $promoName){
if ($this->promoCode) {
return $this->getValidPromoCode($promoName);
} else {
throw new Exception('Cliente sem código de promoção');
}
}
protected function getValidPromoCode(string $promoName) {
if (false === $this->promoCodeExpired()) {
return $this->getPromoExists($promoName);
} else {
throw new Exception('Promoção Expirada');
}
}
protected function getPromoExists(string $promoName) {
if ($this->promoName == $promoName) {
return $this->promoCode;
} else {
throw new Exception('Promoção não existe mais');
}
}
}
11

12. Não use Else
2

13. Problemas:
● Redundância
● Dificuldade em dar manutenção
13

14. protected function indexAction()
{
if ($this->security->isGranted('ADMIN')) {
$view = 'admin/index.html.twig';
} else {
$view = 'home/access_denied.html.twig';
}
return $this->render($view);
}
14

15. protected function indexAction()
{
// early return + defensive approach (pessimista)
if ($this->security->isGranted('ADMIN')) {
return $this->render('admin/index.html.twig');
}
return $this->render('home/access_denied.html.twig');
}
15

16. protected function indexAction()
{
// variável com valor padrão
$view = 'admin/index.html.twig';
// defensive approach (otimista)
if (false == $this->security->isGranted('ADMIN')) {
$view = 'home/access_denied.html.twig';
}
return $this->render($view);
}
16

17. foreach ($orders as $order) {
// early return + defensive approach (pessimista)
if ($order->paid()) {
$report[] = [$order->status => 'Paid'];
continue;
}
$report[] = [$order->status => 'Not Paid'];
}
17

18. Outras técnicas:
● Polimorfismo
● Null Object Pattern
● Strategy Pattern
● State Pattern
18

19. Encapsule os tipos
primitivos
3

20. Problemas:
● Menor legibilidade
● Difícil de testar
20

21. class Pedido
{
public function notificarComprador(String $email)
{
if (false == filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidEmailException;
}
return $this->repository->sendEmail($email);
}
}
21

22. class Email
{
public $email;
public function __construct(String $email)
{
if (filter_var($email, FILTER_VALIDATE_EMAIL) === false) {
throw new InvalidEmailException;
}
return $this->email = $email;
}
}
class Pedido
{
public function notificarComprador(Email $email)
{
return $this->repository->sendEmail(new Email($email));
}
}
22

23. Envolva suas coleções
em classes
4

24. Problemas:
● Baixa coesão
● Não cumprir o Princípio da Responsabilidade Única
24

25. “
Crie uma classe dedicada para a
sua coleção (collection).
25

26. Use apenas um ponto por
linha
5

27. Problemas:
● Seu objeto sabe demais
● Está violando o encapsulamento
27

28. “ Considere mover o
comportamento para um dos
outros objetos.
28

29. “ Somente fale com seus amigos
próximos, não fale com estranhos.
Lei de Deméter
29

30. // bad
$a->getB()->getC()->getD()->doIt();
// good
$a->doIt($b->doIt());
// exception
$builder->property1("value")->build();
30

31. Não abrevie
6

32. 32

33. Dicas:
● Nome de classe, método ou variável com no máximo duas
palavras
● Evite repetir palavras:
33
// bad
$perfil->criarPerfil();
// good
$perfil->criar();

34. Mantenha todas as
entidades pequenas
7

35. 35
50 linhas
por classe
10 arquivos
por pacote

36. Não tenha mais que duas
variáveis de instância por
classe
8

37. Problema:
● Baixa coesão
37

38. 38
Player
Name
PlayerId
FirstName
LastName
String
String
Integer

39. Não use
Getters ou Setters
9

40. Problemas:
● Redundância
● Menor legibilidade
40

41. “ Enriqueça seu objeto com lógica e
métodos mais valiosos e
significativos.
41

42. class Game
{
private $score;
public function setScore($score) {
$this->score = $score;
}
public function getScore() {
return $score;
}
}
// Using
$game->setScore($game->getScore() + ENEMY_DESTROYED_SCORE);
42

43. class Game
{
public function addScore($delta) {
$this->score += $delta;
}
}
// Using
$game->addScore(ENEMY_DESTROYED_SCORE);
43

44. 44
Quer treinar estes conceitos?

45. 45
Obrigada!
Perguntas?
jessicazanelato.dev