-
Um reforço importante para finalizar
o POO é o entendimento do construtor.
-
Vamos entender melhor essa técnica.
-
Para a programação do POO,
-
um ponto importante
na hora de montar uma classe
-
é o construtor,
a existência do construtor.
-
A função do construtor
ou o objetivo do construtor,
-
é encapsular as variáveis que você
está fazendo dentro da própria classe.
-
Vejamos um exemplo rápido
para entender a didática desse POO.
-
Aqui nesse programa,
ele não está completo,
-
porque eu só estou focado na classe.
-
O meu objetivo é simplesmente
explicar esse início
-
aqui da parte pública da minha classe.
-
Recapitulando,
a classe chamada motor,
-
que será invocada
em algum momento do código
-
antes do "void setup",
possui a parte privada,
-
onde nós vamos declarar
as variáveis que serão utilizadas
-
apenas dentro da nossa classe.
-
E entende-se como classe
até esse ponto e vírgula
-
que tem aqui na frente da chave.
-
É o único lugar na linguagem C++,
que a gente coloca um ponto e vírgula
-
quando fecha uma chave.
-
Você pode perceber
que todas as outras chaves
-
dos nossos programas aqui
ao longo do nosso curso
-
não tiveram esse ponto e vírgula.
-
A minha classe começa daqui de cima,
onde tem essa chave
-
e vai até lá embaixo,
onde tem um ponto e vírgula.
-
Dentro dela, então,
na privada,
-
eu tenho o pino do tipo
inteiro e estado do tipo "bool".
-
O pulo do gato está agora.
-
Na hora que você declarar
como público toda essa parte aqui
-
que será utilizada
ao longo do seu "void loop"
-
que está de uma forma imaginável
aqui embaixo,
-
quando você desenvolver seu software.
-
Então, eu tenho aqui o motor,
-
que está na minha classe
e na frente o argumento "p".
-
Esse "p" que é público para mim,
ele está sendo público
-
porque eu estou declarando ele
aqui na parte pública.
-
Ele vai ser transferido para o pino.
-
Aqui está declarado como privado.
-
Isso chama-se construtor.
-
Então, essa transferência de herança,
ou seja,
-
o que vem da letra "p"
cai na variável pino,
-
chama-se construtor.
-
Então, todas as vezes que você tiver
outros parâmetros, por exemplo,
-
se eu colocasse um outro
parâmetro aqui,
-
declarasse ele como "int",
e aí colocasse aqui tempo.
-
E aqui embaixo,
colocar aqui
-
esse tempo que eu acabei de receber
vai vir para algo do tipo "dia".
-
Então,
eu estou fazendo uma construção,
-
continuo fazendo a construção.
-
O conteúdo de tempo
está indo para dia,
-
só que dia precisa está declarado
em cima.
-
Vou vir aqui como "dia"
para que ele seja privado, né?
-
Protegido dentro da minha classe,
porém o seu conteúdo
-
está vindo de lugares externos.
-
E assim, o "pinMode" seria a declaração
do pino.
-
Aqui eu estou jogando
o nível lógico baixo,
-
aqui tem aquele "void ligar",
que seria para ligar o led
-
ou "void desligar" para desligar o led.
-
E aqui embaixo,
tem uma curiosidade,
-
eu estou retornando o estado
do meu pino.
-
No caso aqui,
vai ser verdadeiro ou falso.
-
Caso você chame
esse terceiro método,
-
porque aqui eu tenho
o primeiro método de ligar,
-
o segundo método desligar
e o terceiro método obter estado.
-
E assim, eu poderia fazer um teste
lá dentro do meu "void loop".
-
Qual é o estado do led
naquele exato momento
-
que eu quiser fazer esse teste?
-
E aí ele me retorna o conteúdo
de estado porque é boolean,
-
ou ele é falso ou ele é verdadeiro.
-
Percebe que o construtor
é essa transferência de parâmetro,
-
do público para o privado.
-
E aí eu trato as informações
de forma privada.
-
E na hora de sair os dados
através do retorno,
-
eu saio de dentro da minha classe
e obtenho esse valor
-
ou esse conteúdo indexado da variável
lá no void loop.
-
E minha classe se torna protegida,
ela está encapsulada.
-
Os dados que permeiam
dentro da minha classe
-
não estão sendo alterados ou estão
vulneráveis ao longo do void loop.
-
Estão todos presos lá dentro da classe.
-
Com isso, a gente entende que o POO
é a melhor forma de você programar
-
programas ou algoritmos
mais complexos
-
ao invés de trabalhar com a estrutura
de cima para baixo,
-
da esquerda para direita,
que é o tradicional.
