-
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 Eu.
-
Ou seja, esse ponto significa método.
-
Método é uma espécie de ação
e o comportamento do objeto,
-
a palavra ponto ligar.
-
Ela está lá dentro da minha classe
e ela faz parte aqui dessa função
-
zinha, dessa pequena função zinha,
que é um digital write.
-
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 modo de ligar
-
eu faço o nível lógico alto.
-
Sair e dentro da função void desligar
-
eu faço o low sai, ou seja,
eu desabilito o led.
-
Entendido isso, vamos agora
entender como se faz uma classe.
-
Você começa com a palavra classe
-
e coloca a palavra let também
a palavra é maiúscula.
-
Ela 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
-
em 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 jogá la pra
-
dentro da privada, da parte privada
que você declarou na etapa anterior.
-
Isso garante que o seu conteúdo
que acabou de chegar dentro da sua classe,
-
vá direto para o 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 pin mod,
que é o normal.
-
Isso aqui
deveria estar dentro do hot Setup,
-
por que 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 setup
-
para desocupar ou tirar de dentro do void
Setup.
-
Etapas que só interessam só interessam
quando eu tiver um pisca pisca.
-
Isso aqui então, já está trazendo para mim
uma versatilidade.
-
E isso aqui foi uma ferramenta
-
que eu encapsula como sendo um pisca pisca
todos os códigos que eu estiver
-
precisando, um pisca pisca eu não preciso
-
depender do voice setup
para ir lá colocar o pin mod.
-
Eu já deixo dentro
-
da minha caixinha de ferramenta,
independente do que eu já tenho lá
-
dentro do vai de setup eu não tenho que
mexer dentro do void setup
-
eu incluo o pin mod
que é importante para o pisca pisca, para
-
a minha plaquinha,
para meu projeto que tem o pisca pisca,
-
não para todos que eu
-
que eu tiver que colocar um pisca pisca,
eu vou lá no vídeo setup e altero
-
o conteúdo dele, deixo aqui na classe
e que vai funcionar da mesma forma.
-
E aí está lá pin mod ou 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 da frente
do argumento que está na frente do LED.
-
Aí você volta lá.
-
Então na linha 19, na linha 20,
olhe que acontece aqui
-
eu coloquei LED como sendo o meu objeto
e o LED um 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 LED
um dentro da classe,
-
porque não tem mesmo que aparecer.
-
Ela aparece do lado de fora
quando eu precisar de invocar ela,
-
porque assim o que eu faço
eu coloco aqui LED um ponto ligar
-
e aí ele vai entender o que
que na frente do led não tem a variável
-
o 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 pin mod e depois vai ser instanciado
aqui, ou melhor invocado dentro
-
do método ligar porque
-
você colocou ponto ligar e aí
o ligar é para High.
-
Depois você espera um deley lá embaixo
que ele vai executar isso aqui
-
e vai sair daqui de dentro,
ai ele volta para o Voz de Low.
-
O delay vai ser executado
por 1000 milissegundos ou um segundo
-
e na sequência eu tenho o led
um de novo, ou seja, o mesmo objeto
-
e de um porém com o método diferente
que é o ponto 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 a
-
o objeto, o nome desse objeto
que vai aparecer lá fora
-
e o pino que você quer carregar com isso.
-
Olha só como ficou nossa voz de loop.
-
Bem enxuto onde eu tenho agora?
-
Aqui só LED um ponto, ligar LED
ou um ponto desligar e eu coloco um delay.
-
Poderia ter colocado esse delay lá dentro
-
do meu voyage ligar
eu coloco ele aqui dentro, põe 1000 aqui
-
por enquanto e
-
vírgula
e aí eu tiraria o delay daqui de dentro.
-
Olha só como que ficaria bem
simples no meu, vai de louco!
-
E olha que eu estou criando
cuidando de dois LEDs
-
num método, ou melhor,
numa explicação aí anterior,
-
eu teria que colocar
dentro do VAR de loop,
-
ligar para o led azul,
depois desligar para o led azul,
-
ligar para o led verde,
desligar para o led verde
-
com incluindo os seus respectivos pinos
e deles.
-
Aqui, do jeito que eu estou fazendo,
eu posso simplesmente 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 jeitinho que estava.
-
E agora vamos entender o final.
-
O LED eu faço simplesmente
a ativação dele lá em cima.
-
Espero um segundo depois eu desativo.
-
Ele espera um segundo para o LED dois,
que é o verde.
-
Eu faço a ativação de lá em cima.
-
Espera agora meio tempo, meio segundo
e depois eu desligo.
-
Note que o verde é mais rápido
-
para piscar e o azul é mais demorado.
-
Um segundo para o azul,
meio 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 class,
-
não na estrutura inteira do void looping
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.
