[MÚSICA] Na
segunda parte do nosso exemplo então,
nós pegamos, refatoramos aqui a classe carro,
colocamos uma velocidade máxima, ajustamos os testes,
vamos agora então utilizar a herança para a gente ter dois tipos de carro, ta?
Então o que eu vou fazer, Eu vou criar uma classe que eu vou chamar de carro,
CarroDeCorrida, ta?
Essa classe, a ideia é que ela seja superclasse
das minhas classes diferentes de carro, ta?
Então eu vou fazer com que o carro estenda,
extends, CarroDeCorrida, ta?
Eu vou até colocar aqui que a classe CarroDeCorrida, é uma classe abstrata,
então, vamos colocar abstract class, certo?
E, eu vou ter aqui
as informações aqui sobre o meu carro.
Então o que eu tenho aqui que vai ser mais específico desse tipo,
a diferença é o seguinte, já vou explicar aqui,
eu vou ter carro que acelera a partir da soma da potência,
e eu vou ter carro que multiplica número, ta?
Então vão os ser dois algoritmos de aceleração diferentes, ta?
A ideia é de que o resto seja o mesmo, ta?
Então o que eu vou fazer?
Vou tentar jogar aqui algumas coisas para a superclasse, então vou vir aqui,
Refactor, Pull Up, eu passo isso para jogar para a superclasse,
eu vou jogar a velocidade, a velocidadeMáxima, o nome, ta?
O método frear, o getVelocidade, o getNome,
a princípio só o método acelerar, eu vou vir aqui,
e vou falar assim, olha eu quero que você declare lá cima como abstrato, ta?
Vamos ver aqui como que vai ficar.
Vamos ver.
Ta? Ele está reclamando do potência,
eu vou mandar ele fazer mesmo que dê algum erro, certo?
Ele modificou aqui ta?
Porquê?
Porque ele tem aqui no acelerar ta?
Na verdade ele não fez do jeito que eu pedi,
então vou pegar aqui, vou jogar aqui para cá o meu acelerar, certo?
Note que ele já alterou aqui o protected,
e o que eu vou fazer aqui, vai ser declarar esse acelerar
como abstrato, certo?
Ele é uma classe abstrata, ele pode ter métodos abstratos.
Ta? O que eu quero fazer aqui agora, ta?
Então esse cara aqui, ele tem a potência,
eu vou colocar essa daqui, como uma variável privada, ta?
E eu vou subir aqui uma parte do construtor do CarroDeCorrida,
ou seja, o construtor aqui do CarroDeCorrida, certo?
Ele vai receber só a velocidade máxima, e o nome, ta?
A potência ele não tem aqui.
E aí o que é que eu vou fazer?
Na subclasse eu vou aproveitar,
o super, já vou passar
o nome e a velocidadeMáxima,
e aí eu não preciso de colocar novamente, certo?
E aí aqui é só inicializar a potência,
será que ele já está inicializando a velocidade lá com 0?
Vamos ver, opa, Já!
Então já não preciso colocar aqui também, se estivesse eu passaria para lá, ta?
Então essa classe do carro, como ele acelera somando,
eu vou vir aqui,
vou chamar aqui, vou renomear aqui,
como CarroSoma, ta?
Então vou salvar,
note que ele vai renomear o arquivo também para CarroSoma, ta?
E a minha classe TesteCarro aqui,
note que a variável que ela declara é do tipo CarroDeCorrida, certo?
E, agora ele inicializa CarroSoma, ta?
Para a gente fechar aqui essa extração aí da nossa superclasse,
o que eu preciso fazer é rodar o teste e ver se está funcionando.
Vamos ver?
Funcionou tudo direitinho.
O que eu preciso fazer agora, que facilitou bastante o meu trabalho,
é criar ali o carro que multiplica, certo?
Então eu vou vir aqui, vou criar uma nova classe,
que vou chamar de Carro Mult, certo?
Já vou colocar aqui, que a superclasse dele,
é CarroDeCorrida, certo?
Vou pedir aqui, para já criar os construtores para mim, certo?
E herdar os métodos abstratos, tá?
Então aqui, eu vou ter uma outra potência,
que nesse caso aqui, eu quero que ela seja double, certo?
E eu quero que ela seja número entre, 1 e 2, certo?
Então eu vou colocar aqui,
private double potência, certo?
E aí eu vou colocar aqui, se a potência for
maior do que 1, e ela for
menor do que 2, certo?
Eu quero fazer this.
potência igual
a potência que ele está recebendo como parâmetro, ta?
Então note que aqui no construtor eu posso também colocar algum tipo de validação,
isso não tem problema nenhum, ta?
Deixa eu ver aqui, eu vou fazer aqui, se ele não for nada disso,
é a potência que vai receber por exemplo 1.5, tá?
Então o meu método acelerar, ele vai fazer
a velocidade, é,
vezes igual a potência.
Note que no meu carro soma lá,
é mais igual, aqui eu estou multiplicando, ta?
Só que eu também tenho que
verificar aqui, se não atingiu a velocidade máxima.
Bom, para ver se esse carro que multiplica está funcionando corretamente, ta?
Eu vou vir aqui, esse TesteCarro aqui,
já não está com o nome legal, que na verdade é o teste do CarroSoma,
Então eu posso vir aqui e Refatorar, Renomear ele,
TesteCarroSoma, certo?
Opa!
Vamos ver aqui,
ta, agora deu certo.
E eu vou vir aqui, e vou criar uma nova classe
que seria o TesteCarroMult.
Certo?
Vamos lá, vamos ver o que, que modifica aqui?
Do meu TesteCarroSoma?
Eu teria que modificar essa inicialização,
parada é a mesma coisa, o acelerar seria diferente.
O frear aqui também; não, vai ser bem diferente, ta?
Então eu vou copiar tudo aqui,
para eu usar mais ou menos como uma referência, certo?
E vou refazer aqui os testes.
Aqui, ao invés de CarroSoma, vai ser o meu CarroMult, certo?
Então ele está criando ali o teste,
a diferença é que eu vou ter uma potência aqui de 1.5, ta?
Então a princípio o teste parado aqui é igual, o meu teste acelerar,
hum, isso é problema porque, quando a velocidade for 0,
e ele for só multiplicar, vai ser sempre 0, ta?
Então já começou errado aqui, eu tenho
que, a minha velocidade aqui,
vou ter que colocar alguma coisa aqui, se a velocidade for
igual a 0, certo?
Eu vou, o que é que eu faço aqui?
Eu vou, eu tenho inicialiar ela com algum valor, certo?
Então vou fazer aqui, que a primeira velocidade,
ela vai ser igual, por exemplo a 10, se ela for
diferente de 0, que aí eu vou começar a multiplicar, certo?
Vou fazer assim para ficar melhor.
Então vamos lá, pronto, achamos a solução aqui para o problema da velocidade 0, ta?
Então já tenho que ter aqui, acelerarUmaVez,
Que aí a velocidade tem que ser 10,
e eu vou ter aqui o teste acelerar DuasVezes,
que aí tem que ser 15, que aí já vai
ser ali o 10 vezes 1.5,
então vou fazer agora c.acelerar, certo?
Tem que ser 15, olha eu tenho aqui o meu testFrear,
certo?
Tá ok, aqui também para zerar a velocidade.
E eu tenho aqui até a velocidade máxima, ta?
Então vou salvar, vou rodar todos os testes aqui
que tem Carro, certo?
Vamos ver se está tudo passando.
Maravilha!
Então todos os testes aqui do CarroMult estão passando,
todos os testes do CarroSoma estão passando, ta?
Então com isso a gente criou a nossa herança,
a gente tem agora carros que aceleram com algoritmos diferentes, ta?
Isso encerra a segunda parte aqui da nossa, do nosso Hads On,
e na terceira parte a gente vai estar criando uma corrida,
para ver que carro chega na frente.
Ta certo?
Então, muito obrigado, até à próxima parte!
[MÚSICA]
