Contribuindo para coesão e encapsulamento através do design de código Tell Don't ask
Published: 2024-04-11 12:44:56

Tell Don’t Ask, em português diga não pergunte, é um princípio de design de código no qual através de um objeto ocorre a combinação de dados e comportamentos. Este design traz a lembrança de que orientação objeto baseia-se no comportamento que determinado objeto tem sobre seus dados e assim transferindo a responsabilidade a quem é de direito. 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fpzfm15i7adpcdl1mwoi.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4pnvactd6ykjsbpbnjna.png)

As duas figuras acima ilustram a relação entre dois objetos e suas responsabilidades em que a primeira figura mostra o objeto “chamador” fazendo diversas perguntas a outro objeto e tomando decisões com bases nas respostas que recebe, já a segunda imagem representa uma comunicação na qual o objeto “chamador” apenas diz ao outro o que fazer e assim toda a lógica concentra-se em quem é o dono dos dados. 

Por exemplo, vamos imaginar que temos uma classe denominada carro e ela tem como propriedade velocidade. Porém iremos considerar uma velocidade limite de 120km.

```java
class Carro(
   var velocidade: Int
)
```

E ao utilizarmos uma instância desta classe queremos fazer com que o carro acelere.

```java
fun main() {
   val carro = Carro(0)
   if (carro.velocidade < 120) {
       if ((carro.velocidade + 10) > 120) {
           carro.velocidade = 120
       } else {
           carro.velocidade += 10
       }
   }
}
```

E aqui é perceptível que há algo errado, pois quem chama o objeto precisa verificar se a incrementação da velocidade não irá ultrapassar o limite permitido, 120km. 

Já utilizando o conceito Tell Don’t Ask o código ficará mais conciso e as responsabilidades são definidas de acordo com o escopo de cada objeto.

```java
fun main() {
   val carro = Carro(0)
   carro.acelerar()
}
```

Agora quem chama o objeto não precisa implementar a lógica para incrementar a velocidade do objeto carro e sim somente chamar o método acelerar. 

Já a classe carro fica responsável pelo o comportamento de acelerar, detendo toda a lógica de como fazê-la.

```java
class Carro(
   private var velocidade: Int
) {
   fun acelerar() {
       if (this.velocidade < 120) {
           val novaVelocidade = this.velocidade + 10
           if (novaVelocidade > 120) {
               this.velocidade = 120
           } else {
               this.velocidade = novaVelocidade
           }
       }
   }
}
```

Além de contribuir para um código limpo e coeso onde as responsabilidades são divididas para cada objeto de acordo com seu escopo, também contribui para a reutilização de código, pois quem utilizar esta classe carro não precisará perguntar sobre a velocidade do carro para tomar decisões e sim somente dizer o que é necessário. 

Portanto, Tell Don’t Ask só reforça o pilar do encapsulamento que encontramos ao estudar programação orientada a objetos. O encapsulamento consiste em adicionar uma camada de segurança à aplicação escondendo suas propriedades e expondo pontos de interações. Deste modo, os dados só podem ser manipulados internamente e quem utiliza só precisa dizer o que deseja e não perguntar, assim como fazemos com nossos controles remotos de televisão, não sabemos como ele funciona internamente e apenas precisamos dizer para que ele ligue a TV, mude de canal, baixe e aumente o volume, entre outras funcionalidades, mas como isso de fato funciona não é preciso saber.