OOP do jeito certo: Passagem de Mensagem e os Quatro Pilares
Tags: oop, programming
Published: 2024-01-22 13:07:55


Acabei de assistir [um vídeo antigo do ThePrimeagen](https://www.youtube.com/watch?v=STtOP6d7K_4) sobre passagem de mensagens na OOP, e quis escrever um artigo que explicasse melhor o tópico. Enãto aqui estamos.

Passagem de mensagens, para aqueles que não sabem, é essencialmente um gatilho para um objeto agir. De alguma forma, "passagem de mensagens" tornou-se "evocação de métodos". JavaScript, apesar de não ser [Smalltalk](https://pt.wikipedia.org/wiki/Smalltalk), já possui um mecanismo interessante para mensagens. Você pode acessar dinamicamente os campos de um objeto:

```js
obj['mensagem'](...params);
```

Isso permite que você acesse o comportamento associado à mensagem. Comportamento não é o mesmo que uma chamada de método. Comportamentos podem ser muitos métodos privados de uma vez, métodos públicos ou até mesmo uso de referência de outros objetos. O importante é a API declarativa que a passagem de mensagens possibilita. Isso enforça o princípio da `Abstração`.

```js
const jose = new Pessoa('José');

jose['saudacao'](); // imprime "Olá, eu sou o José!"
jose['soma'](2, 2); // imprime "Eu sou ruim em matemática!!!"
```

Se dermos a mesma mensagem para diferentes objetos, o que acontece? Obtemos `Polimorfismo`.

```js
const jose = new Pessoa('José');
const fusca = new Carro('Fusca');
const pimenta = new Cachorro('Pimenta');

jose['saudacao'](); // imprime "Olá, eu sou o José!"
fusca['saudacao'](); // imprime "Beep!"
pimenta['saudacao'](); // imprime "Au Au!"
```

Para ensinar matemática a José, não podemos simplesmente abrir o cérebro dele e enfiar matemática lá dentro — não é assim que o cérebro funciona na vida real, então não será assim que modelaremos nosso sistema aqui. José será ensinado corretamente. Vamos apresentá-lo à Maria, uma professora:

```js
const jose = new Pessoa('José');
const maria = uma Professora('Maria'); // Note a nova classe

maria['saudacao'](jose); // imprime "Olá, José, eu sou a Maria!"

jose['saudacao-de-volta'](maria); // imprime "Olá, Maria, prazer em conhecê-la!"

// José até sabe como `saudar-de-volta` — que chique.
```

Vê como a mensagem `saudacao` é diferente desta vez? Comportamentos podem ser modificados com parâmetros. Este é também um ótimo exemplo do princípio de `Herança`: Um professor é uma pessoa, e todas as pessoas sabem como saudar. Maria, sendo professora e pessoa, sabe como saudar também.

Finalmente, vamos ensinar matemática para José:

```js
// Verificando novamente se José sabe matemática:

jose['soma'](2, 2); // imprime "Eu sou ruim em matemática!!!" ainda!

// Nada de novo. Vamos fazer Maria ensiná-lo:
maria['ensinar'](jose, 'matemática');

jose['soma'](2, 2); // imprime "2 mais 2 são 4."
```

O que aconteceu com José? Maria simplesmente enfiou matemática em seu cérebro? Vamos dar uma olhada no comportamento `ensinar` abaixo. Como objetos não podem mudar o estado de outros objetos, você deve passar a mensagem e deixá-los lidar com isso.

```js
class Professor extends Pessoa {
  // ... outras lógicas vão aqui

  ensinar(pessoa, assunto) {
    pessoa['aprender'](assunto);
  }
}
```

Essa regra de não mexer no estado interno de outro objeto é chamada de `Encapsulamento`. Apenas José pode realmente aprender — Maria só pode ajudar. José é um bom aluno e, agora que ele sabe matemática, ele se comporta de maneira diferente quando é pedido para somar dois números.

E aí está: exploramos os quatro pilares da Programação Orientada a Objetos através da Passagem de Mensagens.

Espero que tenha gostado!