<img src="https://safebooru.org//samples/3233/sample_dd8ac0057c4f68ecd35569215ec138566e3f6905.jpg?3360979" alt="">
A Programação Orientada a Objetos (POO) é, na verdade, mais simples do que parece. Se você ainda não a compreende, é
possível que a explicação que você recebeu tenha sido inadequada.
<h1>Programação Funcional</h1>
Vamos começar entendendo o que pode tornar o código complexo ao longo do tempo. Imagine que criamos um arquivo
TypeScript contendo uma função que realiza diversas tarefas.
<pre><code class="language-typescript">function deveresDeCasa() {
 if (acordar) {
 arrumarCama();
 escovarOsDentes();
 tomarCafeDaManha();
 }

 if (acordado &amp;&amp; comido) {
 tomarBanho();
 seArrumar();
 sairParaTrabalhar();
 }
}
</code></pre>
Esse código funciona? Sim. Mas é o mais recomendável? Não. O problema é que toda a funcionalidade está dentro de um
único escopo. Embora seja relativamente fácil de entender inicialmente, com o tempo, o código se torna complexo e
difícil de manter.
Então, qual seria uma solução para esse problema? A primeira abordagem seria dividir o código em funções separadas. Em
vez de usar condições como <code>if (acordar) {}</code>, poderíamos transformar em funções como <code>function Acordar() {}</code>. Dessa
forma, toda a funcionalidade relacionada a acordar, como arrumar a cama, escovar os dentes e tomar café da manhã,
ficaria contida dentro de <code>Acordar()</code>. Isso facilita a manutenção do código, garantindo que essas ações sejam realizadas
apenas no contexto adequado.
No entanto, isso ainda não resolve completamente o problema. Se tivermos uma função chamada <code>Rotina</code>, ela poderia
facilmente se encher de dezenas de outras funções, o que nos levaria de volta ao problema inicial de excesso de
condições e complexidade.
<pre><code class="language-typescript">// acordar.ts

class Acordar {
 public arrumarCama() {}
 public escovarOsDentes() {}
 public tomarCafeDaManha() {}
}
</code></pre>
A vantagem dessa abordagem é que o código fica organizado, separado em arquivos distintos, e com o uso restrito a uma
classe específica. Isso evita que funções sejam chamadas fora de ordem ou em contextos inadequados.
Podemos então criar uma instância dessa classe para utilizar as funcionalidades encapsuladas:
<pre><code class="language-typescript">// index.ts

const periodoDaManha = new Acordar();

periodoDaManha.arrumarCama;
</code></pre>
Mas será que POO é só isso? E quanto a conceitos como herança, polimorfismo e encapsulamento? Vamos explorar esses
conceitos para ver como eles nos ajudam a escrever um código mais limpo e eficiente.
<h2>Herança</h2>
Herança é um dos pilares da POO e nos permite estender funcionalidades de uma classe para outra. Por exemplo,
<code>escovarOsDentes()</code> não é algo que fazemos apenas ao acordar; podemos fazer isso após o almoço, antes de dormir, etc.
Para evitar repetição de código (princípio DRY - Don&#39;t Repeat Yourself), podemos criar uma classe genérica para escovar
os dentes e utilizá-la em várias outras classes.
<pre><code class="language-typescript">// common.ts
export class EscovarOsDentes {
 public escovar() {
 console.log(&#39;Escovando os dentes&#39;);
 }
}
</code></pre>
No arquivo <code>acordar.ts</code>, podemos estender essa funcionalidade:
<pre><code class="language-typescript">// acordar.ts

import { EscovarOsDentes } from &#39;./common&#39;;

class Acordar extends EscovarOsDentes {
 public arrumarCama() {}
 public tomarCaféDaManha() {}
}
</code></pre>
Se tivermos uma função similar para a rotina noturna, poderíamos estender a classe <code>EscovarOsDentes</code> da mesma forma,
garantindo que o código seja reutilizado de maneira eficiente.
<pre><code class="language-typescript">// index.ts

const periodoDaManha = new Acordar();
const periodoDaNoite = new Dormir();

periodoDaManha.escovar();
periodoDaNoite.escovar();
</code></pre>
<h2>Polimorfismo e Encapsulamento</h2>
Polimorfismo e encapsulamento são conceitos que permitem maior flexibilidade e segurança no código.
O polimorfismo nos permite tratar objetos de diferentes classes de forma unificada, nunca sabemos como um ato de
<code>fazerSom()</code> pode vir de maneiras diferentes dependendo do animal.
Enquanto o encapsulamento protege o estado interno dos objetos, expondo apenas o necessário - usando <code>private</code> ao invés
da <code>public</code> e ficando reservada apenas dentro da classe.
<h3>Polimorfismo</h3>
O polimorfismo é a capacidade de uma função ou método agir de forma diferente com base na classe do objeto que a invoca.
Por exemplo, podemos ter diferentes classes derivadas de uma classe base, onde cada uma delas implementa um método de
forma diferente, mas todas compartilham a mesma interface.
<pre><code class="language-typescript">class Animal {
 public fazerSom() {
 // Método genérico que será sobrescrito
 }
}

class Cachorro extends Animal {
 public fazerSom() {
 console.log(&#39;Latido&#39;);
 }
}

class Gato extends Animal {
 public fazerSom() {
 console.log(&#39;Miau&#39;);
 }
}

const animais: Animal[] = [new Cachorro(), new Gato()];

animais.forEach(animal =&gt; animal.fazerSom());
</code></pre>
No exemplo acima, <code>fazerSom()</code> é polimórfico, pois se comporta de maneira diferente dependendo do tipo do objeto.
Dessa maneira, posso usuar a mesma classe, com resultados diferentes em situações diferentes.
<h3>Encapsulamento</h3>
O encapsulamento, por sua vez, envolve esconder a implementação interna de uma classe e expor apenas o necessário para o
uso externo. Isso permite que o código seja mais modular e que mudanças internas na classe não afetem o restante do
código.
<pre><code class="language-typescript">class ContaBancaria {
 private saldo: number;

 constructor(saldoInicial: number) {
 this.saldo = saldoInicial;
 }

 public depositar(valor: number) {
 this.saldo += valor;
 }

 public sacar(valor: number) {
 if (valor &lt;= this.saldo) {
 this.saldo -= valor;
 } else {
 console.log(&#39;Saldo insuficiente&#39;);
 }
 }

 public consultarSaldo() {
 return this.saldo;
 }
}
</code></pre>
Aqui, <code>saldo</code> é um atributo privado, acessível apenas dentro da classe <code>ContaBancaria</code>. As operações de depósito e saque
são controladas através de métodos públicos, garantindo que o saldo não seja manipulado diretamente de fora da classe.
<h1>Instância na Programação Orientada a Objetos</h1>
Uma instância em Programação Orientada a Objetos (POO) refere-se a um objeto específico criado a partir de uma classe.
Quando criamos uma classe, estamos definindo um molde ou um modelo para objetos, mas esse molde, por si só, não
representa algo concreto até que uma instância seja criada.
Pense em uma classe como o plano de uma casa. Ela descreve como a casa deve ser construída, quais são os cômodos,
quantas janelas tem, etc. Mas o plano, por si só, não é uma casa real. Para que isso aconteça, precisamos construir uma
casa baseada nesse plano. Essa casa construída, que é uma manifestação física do plano, é a instância da classe.
Quando criamos uma instância de uma classe, estamos essencialmente construindo um objeto que segue o modelo daquela
classe, com suas próprias propriedades e métodos. Isso permite que várias instâncias de uma mesma classe coexistam, cada
uma com suas características específicas.
Por exemplo, considerando a classe <code>Acordar</code> que discutimos anteriormente:
<pre><code class="language-typescript">// acordar.ts

class Acordar {
 public arrumarCama() {}
 public escovarOsDentes() {}
 public tomarCafeDaManha() {}
}

// index.ts
const PeriodoDaManha = new Acordar();
</code></pre>
Aqui, <code>PeriodoDaManha</code> é uma instância da classe <code>Acordar</code>. Isso significa que podemos chamar os métodos dessa
instância, como <code>PeriodoDaManha.arrumarCama</code>, e essa chamada irá executar o comportamento definido na classe <code>Acordar</code>.
<h1>Por que usar Instâncias?</h1>
<ul>
<li>Isolamento de Estado: Cada instância tem seu próprio estado. Isso significa que, se alterarmos o estado de uma
instância, as outras não serão afetadas. Isso é particularmente útil em cenários onde precisamos de múltiplos objetos
funcionando de maneira independente, mas baseados na mesma estrutura.
</li>
<li>Reutilização de Código: Podemos criar várias instâncias de uma mesma classe sem precisar reescrever o código da
classe. Isso torna o código mais modular e reutilizável.
</li>
<li>Polimorfismo: Através do polimorfismo, podemos criar instâncias de diferentes classes que compartilham métodos
comuns, mas que implementam esses métodos de maneira diferente. Isso nos permite escrever código mais flexível e
genérico.
</li>
</ul>
Em resumo, instanciar uma classe é a maneira como criamos objetos específicos baseados em um modelo genérico, permitindo
que nosso código seja mais estruturado, modular e flexível.
Ficou complicado? Vamos simplificar.
Vamos explorar o conceito de instância em Programação Orientada a Objetos usando algumas analogias para tornar o
entendimento mais claro.
<h1>A Classe como uma Receita, a Instância como o Bolo</h1>
Imagine que uma classe é como uma receita de bolo. A receita descreve todos os passos necessários para fazer o bolo: os
ingredientes, as quantidades, o modo de preparo, etc. No entanto, a receita em si não é um bolo; é apenas um guia de
como fazer um.
Agora, quando você segue a receita e realmente faz o bolo, você tem algo concreto que pode comer. Esse bolo é a
instância da receita. Você pode fazer vários bolos usando a mesma receita, e cada bolo será uma instância separada da
mesma classe.
<ul>
<li>Classe: Receita de Bolo.</li>
<li>Instância: Um bolo específico que você fez seguindo a receita.</li>
</ul>
Você precisa aplicar todos os três? Herança, Polimorfismo e Encapsulamento? Não. Você só precisa lhe dar com isso,
quando realmente precisa lhe dar com isso.
Os três são metodologias que vai se adaptando a sua necessidade, você pode simplesmente ter uma classe composta apenas
de herança, assim, como, você precisa deixar reservado um certo item na classe? Pode-se usar um encapsulamento e assim
vai, então não se prenda a quando criar uma classe, exigir que se use as três regras, sendo que uma só basta. Tudo
depende exclusivamente da sua necessidade.
<blockquote>
Tudo bem Anderson, mas você não explicou o uso do <code>constructor</code> dentro da <code>ContaBancaria</code>, fiquei um pouco perdido
nisso.
</blockquote>
Vamos usar a analogia do projeto da casa para entender o conceito de um constructor em Programação Orientada a
Objetos, seguido de um exemplo em TypeScript.
<h2>A Classe como Projeto de Casa com Personalização</h2>
Imagine que, além de um projeto básico de casa, você possa adicionar personalizações, como a cor das paredes e o tipo de
piso. O constructor é como uma seção no projeto onde você define essas personalizações. Quando você decide construir uma
casa (criar uma instância), você pode passar essas preferências, e a casa construída terá essas características
específicas.
<ul>
<li>Classe: Projeto de uma casa.</li>
<li>Constructor: A parte do projeto onde você especifica as personalizações (como cor e tipo de piso).</li>
<li>Instância: A casa construída com as personalizações definidas.</li>
</ul>
Vamos ver como isso funciona em código:
<pre><code class="language-typescript">// Definindo a classe Casa
class Casa {
 // Propriedades da classe
 cor: string;
 tipoDePiso: string;

 // Constructor para inicializar as propriedades ao criar uma instância
 constructor(cor: string, tipoDePiso: string) {
 this.cor = cor;
 this.tipoDePiso = tipoDePiso;
 }

 // Método para descrever a casa
 descricao() {
 console.log(`Esta casa tem paredes na cor ${this.cor} e piso de ${this.tipoDePiso}.`);
 }
}

// Criando uma instância da classe Casa
const minhaCasa = new Casa(&#39;azul&#39;, &#39;madeira&#39;);

// Usando o método para descrever a instância criada
minhaCasa.descricao();
</code></pre>
<h3>Explicação do Exemplo</h3>
<ul>
<li>Classe <code>Casa</code>: Define um modelo de casa com duas propriedades: <code>cor</code> e <code>tipoDePiso</code>.
</li>
<li>Constructor: Quando criamos uma nova instância de <code>Casa</code> usando <code>new Casa(&#39;azul&#39;, &#39;madeira&#39;)</code>, o constructor é
chamado. Ele pega os valores passados (&#39;azul&#39; e &#39;madeira&#39;) e os atribui às propriedades <code>cor</code> e <code>tipoDePiso</code> da
instância.
</li>
<li>Instância <code>minhaCasa</code>: Esta é a casa específica construída a partir do projeto <code>Casa</code>, com paredes azuis e piso de
madeira.
</li>
</ul>
Método <code>descricao</code>: Este método imprime uma descrição da casa usando as propriedades da instância. Quando chamamos
minhaCasa.descricao(), a saída será:
<code>Esta casa tem paredes na cor azul e piso de madeira.</code>
O constructor em uma classe é o método especial que define como uma instância da classe deve ser inicializada. Ele
permite que você passe valores específicos ao criar uma instância, personalizando-a de acordo com suas necessidades,
como escolher a cor das paredes e o tipo de piso na construção de uma casa.
É isso, espero que tenham gostado. Salve esse artigo para revisões futuras, pois eu sei que você vai precisar voltar
aqui mais tarde (:

Entenda Programação Orientada a Objetos de Maneira Simplificada (POO)

Intermediário

Fique atualizado!