[MÚSICA] Olá, você!
Estamos no curso de Orientação a Objetos com Java.
Meu nome é Eduardo Guerra e hoje eu vou tá falando pra vocês sobre a cadeia de
construtores.
Que que é isso?
A gente vai entender como que os construtores são invocados quando
a gente tem uma hierarquia de classes.
Ou seja, bom, quando você tem ali uma subclasse,
o que que acontece, como que você inicializa as superclasses que
fazem parte dessa classe que você tá instanciando?
Então, você pensa, né: eu tenho ali uma subclasse,
ela tá estendendo uma superclasse...
Como que você vai inicializar, na subclasse,
aquelas coisas que são da superclasse?
Por exemplo, a superclasse, ela tem às vezes vários atributos ali que eles
precisam de uma inicialização no momento que você vai lá e instancia o objeto.
E, aquela coisa né, se a superclasse,
ela precisa instanciar essas variáveis, ela tem construtores pra fazer isso.
Ou seja, ela mesma já tem os seus próprios construtores.
Então, como é que a subclasse faz, né, pra falar assim: "Ô, superclasse, inicializa
aí o que que você tem que inicializar que depois eu faço aqui o que eu preciso".
Então, Java, é obrigatório que construtor,
ele chame outro construtor como sua primeira ação.
Então essa é uma forma de garantir que sempre vai ser inicializado.
Então vai se chamando construtores, construtores, construtores até que se
chame lá o construtor de Object que vai fechar todo esse ciclo aí.
Então a gente tem duas opções pra invocação desses construtores.
A gente pode tá invocando aqui o construtor da superclasse ou
construtor da minha própria classe, sendo que ciclos não são permitidos.
Ou seja, eu não posso chamar construtor...
Eu tenho construtor A,
eu não posso chamar construtor B que chama de volta o construtor A.
Então ele não permite que esses ciclos aconteçam.
E aí pra invocar o construtor da superclasse eu uso super() e pra invocar
o construtor da própria classe eu uso this().
Os dois com parênteses depois.
É como se você estivesse invocando construtor.
Obviamente se esse construtor recebe parâmetros, seja da superclasse ou
da própria classe, você pode, você tem, né, que passar os parâmetros pra ele.
E aí você me pergunta, né: puxa vida,
eu já criei construtores, às vezes até mais de na classe e
nunca botei this() ou super() logo no começo dele.
Então como é que pode, você tá falando aí que é obrigatório,
como é que pode se eu já criei construtor que eu nunca criei isso?
É que, digamos assim, o compilador, ele faz umas coisinhas pra você.
Então quando você não chama o construtor de forma explícita,
é como se ele colocasse pra você super(), né,
uma chamada pro super() sem parâmetros, logo no começo do seu construtor.
Tá certo?
Então, ó, quando você cria o construtor, por exemplo, dessa classe,
chamada MinhaClasse, muito criativo o nome, e não coloca nada no começo,
é como se tivesse esse super() aqui.
É como se você colocasse ali, só que isso aí fica implícito.
Então, vamos entender o que que exatamente o compilador cria pra você.
Então, toda vez que você cria uma classe e você não coloca construtor nenhum,
o compilador vai colocar construtor default sem parâmetros,
que não faz nada, naquela classe.
Ou seja: toda classe, ela tem pelo menos construtor.
Se você não definir nenhum,
construtor default vai ser criado pra você: construtor sem parâmetros.
A outra coisa que faz pra você é quando num construtor você não invoca
outro construtor, é colocada uma chamada ao super(), sem parâmetros, pra você.
Então vamos entender como que muitas vezes a gente tá acostumado
com as coisas que, digamos assim, o compilador já faz pra
gente e que às vezes a gente comete alguns erros e às vezes quando esse erro aparece,
a gente não entende exatamente por que que tá acontecendo aquele problema.
Então imagina esse caso aqui: eu tenho a classe Super, SuperC,
que ela tem construtor que recebe parâmetro inteiro.
E aí, por exemplo, eu crio uma classe SubC, certo, e essa tem construtor vazio.
Esse é caso que vai dar erro.
Por quê?
Porque o construtor default que tá sendo colocado ali,
no caso o super(), ele não existe na superclasse.
Você fala assim: mas o construtor default não é criado pra mim?
É se você não define nenhum construtor.
Então se você definir construtor que recebe algum parâmetro,
como é o exemplo aqui do SuperC, que define esse construtor inteiro,
você não vai conseguir que ele seja chamado por default.
Você tem que chamar ele explicitamente.
Então no caso, pra que funcione, eu precisaria que a minha classe SubC,
ela pode até ter construtor que não seja igual ao da superclasse,
mas tem que invocar ele explicitamente.
Então o construtor do SubC, ele tem que chamar super() passando inteiro,
que aí sim,
esse construtor existe na superclasse e eu não vou tá violando nenhuma dessas regras.
Então lembre-se, né, que todo construtor, toda classe que você criar,
mesmo que ela não tenha superclasse, na verdade ela vai ter o Object,
logo no começo do construtor dela, ela vai tá chamando o super() da classe Object.
E assim a gente tem essa cadeia, né, de que uma classe sempre
vai tá chamando o construtor da superclasse; só quando essas superclasses
retornarem que ele vai tá executando o construtor exatamente daquela classe.
E o construtor tem sempre que ser chamado primeiro.
Você não pode fazer algumas coisas e depois chamar
o construtor da superclasse, tá?
Ele tem que ser chamado primeiro.
Vocês vão ver aí logo seguida tem "hands on" que vai mostrar pra vocês aí,
na prática, aí, como que essa dinâmica da cadeia de construtores funciona.
Então espero que nessa aula tenha ficado pouquinho mais claro como que funciona
aí essa questão da construção dos objetos, a invocação dos construtores quando você
não tem ali a classe sozinha mas ela tá no contexto aí de uma hierarquia de classes,
ela tem superclasses que também têm questões a serem inicializadas.
Muito obrigado!
[MÚSICA]
