Conteúdo

• Nota do Autor
• Começando pelo começo
• Conceitos base
  • Classes
  • Objeto
  • Atributos
  • Métodos
• Pilares
  • Abstração
  • Encapsulamento
    • Modificadores
  • Herança
  • Poliformismo

---

Nota do Autor

Irei direto ao ponto: neste artigo, explorarei os conceitos-chave da Programação Orientada a Objetos (POO) utilizando o Minecraft (para os mais íntimos, o Mine) como exemplo. Sem rodeios, acredito que o Mine constitui uma excelente forma de tornar esses princípios de programação mais concretos e de fácil compreensão.

E quem dentre nós não jogou Minecraft ou não criou um canal durante a era de ouro dessa franquia (que, vale ressaltar, nunca se findou)? Portanto, empregarei esse universo para ilustrar o funcionamento de conceitos como classes, objetos, atributos e métodos, sem me ater aos detalhes sintáticos de linguagens específicas.

---

Começando pelo começo

Para começar, primeiro precisamos entender o conceito de POO, ou Programação Orientada a Objetos. Ela é uma técnica de programação – ou seja, uma forma de pensar em criar algoritmos.

A forma base de se pensar em POO é abstrair, e criar classes para servirem de modelo para a criação dos objetos que serão usados nos programas – perceba que POO tenta se voltar mais para a realidade, pois tenta pegar objetos do mundo real e transformá-los em código.

Ela segue alguns Pilares e conceitos base, que veremos a frente. De todo modo, POO é uma das formas mais utilizadas em toda a computação, sendo uma das formas de resolver problemas computacionais mais bem aceitas e empregadas.

---

Conceitos base

Classes

Classe é a forma, modelo que será seguido contento: ações e características
Quando se usa POO, tudo ou quase é uma classe e por tabela é um objeto.

Com isso em mente e o conceito do que seria programação orientada a objetos, temos que pensar que para representarmos algo do mundo real, precisamos primeiro fazer o modelo da “coisa” ou “ser”, para isso criamos as classes, que por vez elas terão as suas respectivas características → atributos e suas ações → métodos.

Vamos a um exemplo no Minecraft:

Tudo no Minecraft é um objeto, ou seja, o seu personagem, os mobs, os blocos, o mundo

Então eles foram feitos a partir de classes que por sua vez são modelos desses objetos → o que terão e como irão se comportar

Dessa forma podemos, não só reutilizar código, como modularizar em classes o que o programa vai fazer de modo que vai gerar mais facilidade na hora de criar e manter o sistema.

Transformando em código:

Para criar uma classe, usamos a palavra reservada class:

As classes por padrão começam sempre com as primeiras letras em maiúscula → uso do PascalCase. Elas possuem:

• atributos → o que aquele modelo terá
• métodos → deve sempre começar com o método construtor que vai iniciar a classe, eles são as ações do modelo

---

Objeto

É o uso da classe
Um Objeto é a instancia de um classe.

Pense que o objeto é o uso do modelo e ele que usamos para interagir com o sistema, contendo todos os atributos e métodos da classe.

Vamos a um exemplo no Minecraft:

Como vemos no exemplo, a classe Jogador possui três instâncias -> Jogador1, Jogador2, Jogador3.

• Essas instâncias possuem as características e ações definidas na classe Jogador.

Transformando em código:

• Para criar objetos, precisamos instanciar as classes e, para isso, usamos a palavra-chave:

new NomeDaClasse()

• Devemos usar parênteses para a chamada do método construtor.

Lembrando que não podemos adicionar ou remover atributos ou métodos pelo objeto, somente a classe pode fazer isso.

---

Atributos

Os atributos são as características da classe (ou objeto).

Podemos pensar que os atributos são essenciais, uma vez que são eles que a classe vai utilizar e definir o que os objetos terão.

Vamos a um exemplo no Minecraft:

• A o observarmos, vemos que os atributos são a base para uma classe, já que são eles que serão usados quando for realizar alguma ação ou até mesmo serem utilizados por outro objeto.

Transformando em código:

• Podemos definir um atributo desse modo:

modificador tipo nomeDoAtributo

• E para usá-los usamos a palavra reservada → this servindo para referenciar que vamos usar os atributos e métodos “dessa” ou “essa” classe;

• Agora, vamos usa-lo, deste modo: objeto.atributo

💡 obviamente cada linguagem tem sua sintaxe, mas de modo base a forma como usamos e criamos se repete em outras linguagens

---

Métodos

Tudo aquilo que as classes fazem.

Os métodos são responsáveis pelas ações de uma classe (ou seja, do objeto), sendo que possuímos dois tipos:

• construtor → inicializa a classe, (obrigatório) e o primeiro a ser executado assim que a classe é invocada (quando usamos o new)
• métodos não construtores → todo e qualquer outro método que não é o construtor

Vamos a um exemplo no Minecraft:

No exemplo vemos que um objeto Jogador ele precisa de algumas ações básicas como:

🤔 Quer dizer então que existe uma etapa antes de você jogar que é criar o jogador isto é chamar o método construtor para que inicialize o objeto com algumas informações como nome, skin, etc.

Transformando em código:

• Para criar o método construtor:

modificador NomeDaClasse(tipo parametro) {}

• Para criar métodos não construtores:

modificador nomeDoMetodo() {}

• Agora vamos usá-los:

🤯 Está é apenas foi a primeira parte: senta, pega uma água, respira e voltemos aos conceitos.
❗ Todos os conceitos são importantes, lembre-se de entender eles bem, para isso, pratique

---

Pilares

De forma que a Programação Orientada a Objetos se baseia em alguns pilares.

Abstração

Jogar os detalhes para debaixo do tapete

Deixar apenas o essencial de que o objeto precisa.
Por exemplo, vamos abstrair um jogador do Minecraft, ou seja, pensar nas características e ações mais importantes:

Ao Transformar em código serial algo assim:

• No caso, vamos abstrair a questão da linguagem, já que o importante são os conceitos
• Assim criamos uma classe – modelo, que possui apenas o que é importante para um jogador

💡 Por convenção, usamos o nome da classe no singular e usando o pascal case

---

Encapsulamento

cada um no seu quadrado

• Deixar as características do objeto (atributos) e o que ele faz (métodos) acessível apenas a ele mesmo e seu acesso é controlado
• Usaremos o exemplo abaixo para representar encapsulamento:

❗ Caso não exista este pilar, ou seja, os atributos não estão encapsulados – no seu “quadrado” ou melhor no seu objeto, logo, qualquer um pode acessar diretamente

Transformando em código:

• Assim podemos observar que não possuir um encapsulamento correto pode ocorrer em falhas no sistema

• Logo, para resolver isso devemos encapsular o que a classe Jogador possui para que somente seja acessado seus atributos e métodos, dentro da própria classe:

  • Quando criarmos outros objetos tanto da classe Jogador ou mesmo tentar acessar algum atributo do Jogador, não será possível.
  • Isso graças aos modificadores de acesso que são palavras-chaves, escritas nos atributos e métodos para definir como eles serão encapsulados, logo, encapsulamos usando modificadores.

• Antes estava public, agora está private, os modificadores mudaram e o encapsulamento também e agora não é possível acessar os atributos dentro dos objetos da classe Jogador diretamente:

• Se tentarmos acessar diretamente os atributos irá retornar erro, já que ele está como private

• Assim só posso modificar e ler o valor dele usando getters e setters que são métodos definidos na classe e eles tem como modificador público (public)
  • getters -> uso para pegar o valor
  • setters -> uso para modificar o valor

Modificadores

• Modificador: public

• Modificador: private

• Modificador: protected

• Modificador: static

---

Herança

copia, mas não faz igual

Nesse pilar pense assim: há uma classe pai, aquela que vai ser usada para ser a base das classes filhas, ou seja, você vai copiar uma classe -

• Na verdade o que será copiado são os métodos e atributos e colar em outra classe.

De forma que ao exemplificar pensando ainda no Minecraft, ficaria assim:

• Temos uma classe (modelo) → servindo para conter as características e ações básicas de Jogador e Mob

• Sendo que tanto Jogador e Mob terão o que a classe pai tem, mas serão vistos como outras classes, ou seja, é uma copia do que o modelo tem

Porém, não é igual, as filhas podem sobrescrever o que uma ação faz para ficar personalizada, só que isso é Polimorfismo

Transformando em código:

---

Poliformismo

Eu sou o Douglas, Você não é o Douglas

Com esse pilar devemos se basear na Herança, já que o poliformismo é ter um mesmo metodo, o que o objeto faz, que possui o mesmo nome da classe pai e ma filha, só que com uma forma diferente de fazer as coisas.

Voltando ao nosso Minecraft:

Como temos, Jogador e Mob que possuem formas diferentes de fazer a mesma coisa, ou seja:

• Os dois atacam, correm, etc, porém o Mob tem certos tipos de ataque diferente do Jogador

Logo para fazer isso além de usar a Herança, temos que sobrescrever o que jaz escrito em Personagem, para cada classe filha que tenha que possuir uma ação possuindo o mesmo nome, mas varia em comportamento

Transformando em código:

---

Este é o fim...

Chegamos ao fim do artigo, espero que tenha sido útil, caso tenha algum erro ou outro comentário, será muito bem vindo, pois vai enriquecer mais nós mesmos!

---