Conteúdo
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 →
thisservindo 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
gettersesettersque 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!
Top comments (0)