AICSS CAP08 2025 VA04 POO CONSTRUTOR

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 vai 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 paramos, 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 o dia

para que ele seja

privado, né?

Dentro, protegido dentro da minha classe,
porém seu conteúdo

está vindo de lugares externos e assim

o Pi mod seria declaração do pino.

Aqui eu estou jogando
o nível lógico baixo,

aqui tem aquele void de ligar
que seria para ligar

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 caso você

chame essa, esse segundo,
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 looping.

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 ele é booleano.

Ou ele é falso ou ele é verdadeiro.

Percebe que o construtor ele é.

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 Lupe

e minha classe ela 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 Lupe
estão todos presos lá dentro da classe.

Com isso a gente entende que o Pi o é.

A melhor forma de você programar
programas ou algoritmos mais complexos

ao invés de trabalhar
com a estrutura de cima

pra baixo, da esquerda
para direita, que é o tradicional.