AICSS CAP08 2025 VA03 POO CLASSES METODOS E OBJETOS

Você sabe o que é objetos
e métodos

dentro da linguagem de programação
orientada a objetos?

Vamos discutir
um pouco mais sobre isso.

Dentro da linguagem
de programação orientada objeto

nós temos recursos
que vão tornando a programação

um pouco mais profissional
e ao mesmo tempo flexível

para fazer alterações
rápidas sem quebrar muito o código.

Outra vantagem de usar
métodos e objetos

é que você pode criar
uma caixa de ferramenta exclusiva

para você programador
que tem facilidade em desenvolver

uma parte do programa e reaproveitar
isso nos demais programas.

Afinal, os bastidores do código

não são tão importantes para o usuário
que está usando seu sistema.

E você, como programador,
pode ganhar tempo reaproveitando

partes do seu código
para projetos futuros.

Vejamos aqui uma aplicação prática

de como fazer objetos e métodos
usando o pisca pisca.

Nesse código nós vamos começar aqui
do nosso "void setup".

Percebe que ele está "vazio",

já que a parte de programação
do pin mode

ou da configuração do pin mode,

que é importantíssima para fazer
os pinos se alimentarem

elas em vez de estar dentro
do void setup,

elas foram parar dentro
da nossa classe.

E ainda na sequência nós temos
o "void loop"

que vai na verdade instanciar
os nossos métodos.

Então, vejamos.

O que é um objeto?
O que é um método?

Tudo começa antes do "void setup".

Percebe que aqui tem uma palavra "Led"
com a letra L maiúscula

e um "led1" com letras minúsculas.

Essa palavra Led com letra maiúscula
é o nosso objeto.

Percebe que aqui em cima
esse Led

também aparece com a letra maiúscula.

Então o nome que vem
logo abaixo do "public"

tem que bater com a palavra
que você está criando lá de fora

que vem antes do void setup.

Na sequência eu tenho o "led1".

Esse led1 faz parte do objeto.

Porém, ele não aparece
aqui dentro da classe.

Ele vai aparecer lá fora
dentro do "void Loop",

que é aonde eu vou instanciar meu objeto.

Então eu começo com o "Led"
criando dentro da classe Led maiúscula

e o "led1" para fora dele,
aonde eu vou instanciar.

Pois bem, percebe que tem um ponto
depois da palavra "led1."?

Esse ponto vai me dizer
qual é o comportamento desse objeto.

Ou seja,
esse ponto significa método.

Método é uma espécie de ação
é o comportamento do objeto.

A palavra ".ligar"
está dentro da minha classe

e ela faz parte aqui dessa função,

dessa pequena função
que é um "digitalwrite".

Ou seja, faço o nível lógico alto

sair pelo o pino
que está sendo carregado.

Já já a gente chega no entendimento disso.

Por enquanto você só tem que entender
que dentro do "void ligar"

eu faço o nível lógico alto sair.

E dentro da função "void desligar"

eu faço o "low" sair, ou seja,
eu desabilito o led.

Entendido isso, vamos agora
entender como se faz uma classe.

Você começa com a palavra "class"
e coloca a palavra "Led" também.

A palavra L maiúscula
tem que estar aqui em cima,

aqui no "public" e lá do lado de fora.

E aí você vai fazer
uma construção da sua classe,

sempre com duas partes,
uma parte privada e uma parte pública.

Na parte privada
você vai declarar os pinos

que serão utilizados dentro desse escopo
e não mais que isso.

Então a classe para ela existir,

ela precisa ter pequenas gavetas
na memória do microcontrolador.

E essas gavetas são as variáveis.

Nesse caso,
eu estou declarando a gaveta "pino"

como sendo inteira.

Na parte pública eu vou colocar aqui

o nome do meu objeto
e aí na frente dele

eu vou colocar o local onde vai vir
o parâmetro,

o primeiro parâmetro quando eu carregá-lo.

Então aqui está vindo o parâmetro "p",

"p" minúsculo e ele é do tipo inteiro.

Quando eu entrar
na minha parte pública

eu faço uma transferência
obrigatória aqui de parâmetro.

A variável que você declarar
aqui dentro,

você precisa jogar para dentro
da privada,

da parte privada
que você declarou na etapa anterior.

Isso garante o que?

Que o seu conteúdo que acabou
de chegar dentro da sua classe,

vá direto para um conteúdo privado
para você poder trabalhar aqui dentro

e não deixar exposto para os outros
escopos do seu projeto.

Isso garante segurança
na hora de montar o projeto

e evitar que variáveis
sejam alteradas inadvertidamente.

Outra coisa que acontece aqui
é o "pinMode",

que é o normal.

Isso aqui deveria estar dentro
do void Setup.

Por quê nós colocamos aqui?

Para mostrar para você
que dentro da parte pública

eu posso fazer o que eu bem
entender com o código,

mesmo etapas ou comandos
que vão dentro do void setup

para desocupar ou tirar de dentro
do void setup

etapas que só interessam
quando eu tiver um pisca pisca.

Isso aqui então, já está trazendo
para mim uma versatilidade.

Se isso aqui for uma ferramenta
que eu encapsulo

como sendo um pisca pisca,

todos os códigos que eu estiver
precisando um pisca pisca

eu não preciso depender do void setup
para ir lá colocar o pinMode,

eu já deixo dentro
da minha caixa de ferramenta,

independente do que já tem lá
dentro do vai de setup.

Eu não tenho que mexer
dentro do void setup

eu incluo o pinMode
que é importante para o pisca pisca,

para a minha placa,
para meu projeto que tem pisca pisca,

não para todos que eu tiver
que colocar um pisca pisca,

eu vou lá no void setup
e altero o conteúdo dele.

Deixo aqui na classe
e que vai funcionar da mesma forma.

E aí está lá "pinMode"
o "pino" e "output".

Agora de onde está vindo o pino?

O pino, como eu disse,
está vindo da letra "p".

E da letra "p"
está vindo da onde?

Está vindo do argumento
que está na frente do "Led".

Aí você volta lá então na linha 19,
na linha 20.

Olha o que acontece aqui.

Eu coloquei "Led"
como sendo o meu objeto

e o "led1" como sendo
parte do meu objeto.

Só que aí,
olha o que tem aqui dentro,

um número.

Esse número ele está vindo indexado
para exatamente aqui dentro.

Só que não aparece a palavra "led1"
dentro da classe,

porque não tem mesmo que aparecer.

Ela aparece do lado de fora
quando eu precisar invocar ela.

Por que assim o que eu faço?
Eu coloco aqui "led1.ligar".

E aí ele vai entender o que?

Que na frente do "led1"
tem a variável,

ou melhor conteúdo "23"
que por sua vez vai cair na letra "p"

que por sua vez
vai cair na letra "pino",

que por sua vez
vai ser carregado no "pinMode"

e depois vai ser instanciado
aqui, ou melhor invocado

dentro do método "ligar",
porque você colocou ".ligar".

E aí o "ligar" é para "high".

Depois você espera um "delay"
lá embaixo

que ele vai executar isso aqui
e vai sair daqui de dentro,

ai ele volta para o "void loop".

O "delay" vai ser executado
por 1000 milissegundos

ou 1 segundo.

E na sequência eu tenho o "led1"
de novo, ou seja,

o mesmo objeto "led1" porém,

com o método diferente
que é o ".desligar".

E aí,
eu carrego essa parte do código

aonde lá com o mesmo "pino"
que já está na memória,

eu faço "low" e o led apaga.

Conclusão, todas as vezes
que você criar uma classe

você tem que instanciar
aqui no começo o objeto,

o nome desse objeto
que vai aparecer lá fora

e o pino que você quer carregar.

Com isso olha só
como ficou nosso "void loop".

Bem enxuto,

onde eu tenho agora aqui
só "led1.ligar",

"led1.desligar"
e eu coloco um "delay".

Poderia até ter colocado esse "delay"
lá dentro do meu "void ligar"

eu coloco o "delay" aqui dentro,
põe 1000 aqui

ponho ponto e vírgula

e aí eu tiraria o "delay"
daqui de dentro.

Olha só como que ficaria bem
simples meu "void loop"

E olha que eu estou cuidando
de dois leds.

Em um método, ou melhor,
em uma explicação aí anterior,

eu teria que colocar
dentro do "void loop",

ligar para o led azul,
depois desligar para o led azul,

ligar para o led verde,
desligar para o led verde

incluindo os seus respectivos
pinos e delays.

Aqui do jeito que eu estou fazendo,

eu posso simplesmente então
colocar 1000 aqui dentro

e vai ficar ainda mais enxuto.

E aí eu tiraria os meus "500" aqui

e assim os leds estariam
na mesma cadência.

Eu não vou colocar o play aqui agora,
mas esse é um exemplo para vocês

e do jeito
que eles estão fazendo aqui,

a gente volta agora para onde estava,
do jeito que estava.

E agora vamos entender o final.

O "led1" eu faço simplesmente
a ativação dele lá em cima,

espero 1 segundo,

depois eu desativo ele
espero 1 segundo.

Para o "led2",
que é o verde.

Eu faço a ativação dele lá em cima.

Espera agora meio tempo,
0.5 segundo e depois eu desligo.

Note que o verde
é mais rápido para piscar

e o azul é mais demorado.

1 segundo para o azul,
0.5 segundo para o verde.

Esse método de fazer a programação
com base em classes

para programas mais complexos
e mais elaborados é essencial,

porque quando você tiver
que fazer alguma alteração,

você vai apenas na classe
e mexe apenas na classe,

não na estrutura inteira do void loop
ou do void setup.

E quando você acertar
as versões das suas classes,

elas são herdadas
para programas futuros,

economizando um baita tempo.