Em busca do código perfeito

Uma luz sobre o sobre Object Calisthenics

O que é Object Calisthenics?
Object Calisthenics é um conjunto de nove regras práticas para melhorar a qualidade do código orientado a objetos. Essas regras são recomedações de Jeff Bay no livro "The ThoughtWorks Anthology" e são voltadas para ajudar programadores a desenvolverem sistemas mais claros, visando aplicar o SOLID de forma mais incisiva.
O termo "calisthenics" faz referência a exercícios físicos que ajudam a fortalecer o corpo. Da mesma forma, Object Calisthenics são "exercícios" de disciplina no código para fortalecer suas habilidades em design orientado a objetos.

Por que usar Object Calisthenics?
O principal objetivo dessas regras é melhorar a legibilidade, coesão e desacoplamento do código. Elas funcionam como um guia para evitar problemas como:

• Métodos e classes muito complexos.
• Acoplamento excessivo entre componentes.
• Dificuldade em aplicar testes automatizados.
• Violações frequentes dos princípios de design, como SOLID. A não aplicação destas regras de forma rigorosa não significa que seu código estará ruim ou sujo. Mas utilizando como diretrizes pode transformar significativamente a maneira como você escreve código.

Segue as 9 regras do Object Calisthenics, com alguns exemplos bem simplificado de sua aplicação.

1. Um nível de indentação por método Métodos com muita indentação indicam lógica complexa. Dividir o método em partes menores facilita a leitura e a manutenção.

// Evite:
if (condition1) {
    if (condition2) {
        doSomething();
    }
}

// Prefira:
if (condition1 && condition2) {
    doSomething();
}

1. Não use else O else muitas vezes indica que você não está utilizando bem os conceitos de polimorfismo ou que está adicionando complexidade desnecessária. Em vez disso, foque em tornar o fluxo linear.

// Evite:
if (condition) {
    doSomething();
} else {
    doSomethingElse();
}

// Prefira:
if (condition) {
    doSomething();
    return;
}
doSomethingElse();

1. Um ponto por linha Cadeias de chamadas de métodos (obj.getX().getY().doSomething()) indicam acoplamento excessivo. Crie métodos intermediários para encapsular essas chamadas.

// Evite:
user.getProfile().getEmail();

// Prefira:
user.getEmail();

1. Coleções de primeira classe Não exponha listas ou mapas diretamente. Crie classes que encapsulem as coleções e forneçam métodos para manipulá-las.

// Evite:
List<Order> orders = new ArrayList<>();

// Prefira:
public class Orders {
    private List<Order> orders = new ArrayList<>();
    public void add(Order order) { this.orders.add(order); }
}

1. Sem primitivos nem Strings Evite usar tipos primitivos (como int, double) ou String diretamente para representar conceitos complexos. Em vez disso, use objetos.

// Evite:
String email = "[e-mail]";

// Prefira:
Email email = new Email("[e-mail]");

1. Sem mais de duas variáveis de instância por classe Classes com muitas variáveis indicam excesso de responsabilidade. Separe responsabilidades criando novas classes.

// Evite:
class User {
    String name;
    String email;
    String address;
}

// Prefira:
class User {
    Name name;
    Email email;
    Address address;
}

1. Sem getters e setters Em vez de expor diretamente os dados com métodos como getX() e setX(), forneça comportamentos. Isso promove encapsulamento.

// Evite:
user.getBalance();

// Prefira:
user.withdraw(amount);

1. Sem classes com mais de 50 linhas
   Classes longas geralmente indicam acúmulo de responsabilidades. Divida-as em classes menores e mais focadas.

2. Sem métodos com mais de 5 linhas
   Métodos curtos são mais fáceis de entender e testar. Divida métodos longos em métodos auxiliares menores.

Vantagens do Object Calisthenics

• Maior modularidade: Código com melhor separação de responsabilidades.
• Facilidade de manutenção: Classes pequenas e coesas são mais fáceis de modificar.
• Legibilidade: Código mais curto e organizado é mais fácil de entender.
• Testabilidade: Métodos pequenos e focados são mais fáceis de testar isoladamente.

Limitações
Object Calisthenics pode parecer muito rigoroso, especialmente em projetos grandes ou quando aplicado sem critério. O ideal é tratá-lo como um guia, adaptando as regras à sua realidade e ao contexto do projeto.

Conclusão
Object Calisthenics não é uma solução mágica, mas sim uma abordagem disciplinada para melhorar seu código. Ao adotá-lo, mesmo que parcialmente, você estará praticando habilidades fundamentais de design orientado a objetos que farão diferença em sua carreira e na qualidade de seus projetos.