Introdução a Orientação a Objeto
Tags: beginners, oop, typescript, braziliandevs
Published: 2022-05-17 20:24:05

## Tabela de Conteúdo
- [Conceitos Básicos](#conceitos-básicos)
- [Pilares da OOP](#pilares-da-oop)
- [Sintaxes](#sintaxes)
- [Links Úteis](#links-úteis)

---

## Conceitos Básicos

### Classe

Classes são a representação genérica de algo em nosso código, podendo ser considerada um _"molde"_ a ser utilizado na criação de Objetos _(instâncias da Classe)_.

Em uma analogia mais superficial podemos comparar as Classes às formas de bolo, se tivermos uma forma retangular todo o bolo será retangular, porém cada bolo poderá ter um sabor, uma cobertura, ou não, ou até ser salgado ou doce. Em resumo a Classe seria nossa forma onde definimos, de forma genérica, que todo o bolo feito ali será retangular, porém cada bolo poderá apresentar características únicas, ou seja, a instância da Classe.

### Atributos

Atributos são as características da Classe, variáveis definidas dentro de seu escopo que armazenam alguma informação relevante para a mesma. Sendo que esses atributos podem ser públicos, ou privados, podendo ser acessados diretamente ou indiretamente através de um método, respectivamente.

### Métodos

Métodos são as ações que uma instância de Classe pode executar, em uma análise superficial, podemos dizer que são funções internas de uma Classe.

### Construtor

O construtor é um método especial de toda a Classe, isso porque ele é executado sempre que um novo Objeto é instanciado, dessa forma podemos definir os valores iniciais de nossos atributos, bem como executar algum outro método.

<br />

<small>[Voltar ao topo](#tabela-de-conteúdo)</small>

---

## Pilares da OOP

### Abstração

A abstração diz que não precisamos saber exatamente como algo funciona para utilizar, por exemplo, ao usarmos o WhatsApp, não sabemos exatamente como as mensagens são enviadas e recebidas, sabemos apenas que precisamos de internet e o contato da pessoa e só isso basta para conseguirmos utilizá-lo.

Um exemplo mais próximo do dia a dia de uma pessoa desenvolvedora é a utilização de um ORM para se comunicar com o DB, não sabemos, e nem precisamos saber, como essa ferramenta funciona em seus mínimos detalhes, tudo que precisamos __é entender os métodos e O QUE FAZEM, não COMO FAZEM__.

### Encapsulamento

É a capacidade de alterar a visibilidade dos atributos de uma Classe, fazendo com que eles possam ser acessadas direta ou indiretamente.

### Herança

A herança permite que novas Classes sejam criadas a partir de outra Classe já existente _(super classe)_. Dessa forma podemos _"reutilizar"_ comportamentos, diminuindo a repetição de código.

### Polimorfismo

Faz com que diferentes comportamentos ocorram a depender do Objeto chamado, esses que precisam obrigatoriamente ser instâncias de Classes filhas de uma mesma super classe.

Para aqueles que já utilizaram o React com Classes, a utilização dos métodos de ciclo de vida ilustra perfeitamente esse comportamento, pois em uma aplicação com três componentes de Classe, todos herdam do `React.Component` e mesmo que todos tenham o método `componentDidMount()` seu comportamento é diferente em cada um dos componentes.

<br />

<small>[Voltar ao topo](#tabela-de-conteúdo)</small>

---

## Sintaxes

### Classe

Para definirmos uma classe utilizamos a palavra reservada `class`, seguida do nome da Classe, que por convenção deve ser capitalizada.

``` ts
class Person {}
```

### Atributos

Como irei utilizar TypeScript para trabalhar OOP, além de definir os atributos, é necessários tipa-los. Para tipar os atributos, só precisamos definir seu nome e tipo, para utilizá-los depois basta usar a palavra reservada `this`.

``` ts
class Person {
  name: string;
  age: number;
}
```

### Encapsulamento

Para aplicarmos o encapsulamento aos nossos atributos utilizamos a palavra reservada `private` e por convenção adicionamos um underscore `_` antes do nome do atributo.

_* Essa sintaxe se aplica apenas ao TypeScript, pois o JavaScript não possui a palavra reservada `private`_.

``` ts
class Person {
  name: string;
  age: number;
  private _weight: number;
}
```


### Métodos

Como dito anteriormente, os métodos podem ser considerandos _"funções de classes"_, isso porque sua sintaxe se assemelha muito a funções tradicionais e até mesmo a arrow functions, com a única diferença que não precisamos utilizar a palavra reservada `function`.

``` ts
class Person {
  greetings(): void {
    console.log('Olá!');
  }
}
```

### Geral

Segue abaixo um exemplo da classe pessoa implementando atributos e métodos.

``` ts
class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greetings(): void {
    console.log(`Eu me chamo ${this.name} e tenho ${this.age} anos.`);
  }
}
```

``` ts
// Utilização da classe Person

const p1 = new Person('Gabriel', 21);
const p2 = new Person('Daniela', 23);

console.log(p1.name, p1.age);  // 'Gabriel', 21
console.log(p2.name, p2.age);  // 'Daniela', 23

p1.greetings()  // Eu me chamo Gabriel e tenho 21 anos.
p2.greetings()  // Eu me chamo Daniela e tenho 23 anos.
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdo)</small>

---

## Links Úteis

- [YouTube Código Fonte TV - Programação Orientada a Objetos](https://www.youtube.com/watch?v=QY0Kdg83orY)
- [DevMedia - 4 Pilares da Programação Orientada a Objetos](https://www.devmedia.com.br/os-4-pilares-da-programacao-orientada-a-objetos/9264)
- [TypeScript docs - Classes](https://www.typescriptlang.org/docs/handbook/2/classes.html#handbook-content)
- [DevHints - TypeScript Classes Cheat Sheet](https://devhints.io/typescript#classes)

<br />

<small>[Voltar ao topo](#tabela-de-conteúdo)</small>