Minha volta por cima.
No último vídeo, analisamos a fundo o código do smiley e descobrimos como essas instruções if funcionam.
Agora vamos recapitular esse conhecimento e também passar para outras instruções.
E começamos diretamente com nossa enorme mesa aqui.
Aqui está.
Ok, este parece um pouco complicado.
Vamos discutir isso.
Então, o que temos aqui?
Temos nossa comparação, nossa instrução if, e temos, à esquerda, a sintaxe e, à direita,
a descrição.
E no meio, é assim que você salva isso em voz alta.
E se você fizer isso, reconhecerá ou até mesmo saberá o que essa declaração if faz.
Por exemplo, se você der uma olhada na última linha, se less equals, zero significa que estamos comparando
o X com o valor zero e verificamos se é menor que igual.
Para ser sincero, às vezes eu também procuro os quatro últimos porque não tenho certeza se o zero está incluído
ou não.
Portanto, vamos aos dois primeiros.
Aí temos, se igual, zero.
Portanto, se x for igual a zero, não igual a zero, menor que zero e assim por diante.
Parece muito úmido, mas diga isso em voz alta se estiver assistindo, ou talvez se estiver sozinho em
uma sala e, sim, continue praticando.
Portanto, isso o ajudará muito a reconhecer o que essa instrução if faz.
Está bem.
Se você tiver apenas um registro.
Se registrarmos x, estaremos comparando com zero às vezes, inclusive às vezes não.
Tudo bem.
Está bem.
E, depois, há esse rótulo de meta para este ano, em que pulamos para esta é a declaração verdadeira.
Caso contrário, se nossa declaração for falsa, seguiremos em frente no código, mas também daremos uma olhada nisso.
Ok, aqui está a instrução e diga-a em voz alta.
Então você percebe ou reconhece o que ele faz, e temos que lê-lo da seguinte forma.
Se zero for maior e igual a zero, saltamos para a condição zero.
Sim, eu sei que parece idiota, mas se você continuar fazendo isso, é isso.
Se houver declarações, não haverá problema para você.
Está bem.
E isso é o que esquecemos ou o que recebemos.
Sim.
Se zero maior for igual a zero, pule para a condição zero.
Muito bem, este é o nosso esquema, digamos, sobre isso.
Temos a declaração if, depois temos a comparação.
Temos nosso registro e temos as duas condições de salto.
Uma delas é a nossa condição, que está diretamente após essa instrução if, se a instrução for verdadeira, e
também temos esses go tos e, em relação aos go tos, tente reconhecer que temos go to na frente disso e, depois,
o rótulo, se estivermos encontrando apenas os dois pontos e depois esse rótulo, podemos simplesmente
ignorar ou pular essa função.
Se você fizer alguns remendos com sorrisos depois ou mais tarde neste curso, você passará por isso ou superará isso,
e irá para o rótulo muitas vezes.
E, sim, no meu caso, tive um pouco de dificuldade depois que acabei de memorizar, ok, precisamos ter um go to na
frente disso.
Caso contrário, é apenas uma instrução de salto que termina aqui e podemos ignorar isso.
Muito bem.
Em seguida, temos dois registros.
Portanto, o ritmo está aumentando.
Você já viu isso, mas é absolutamente a mesma coisa que antes.
Em vez de zero, temos agora dois registros.
Então, eu marquei isso dessa forma e também mantemos o mesmo da mesma maneira.
Portanto, neste caso, estamos comparando ou, na primeira linha, estamos comparando.
Se x for igual a v y, na próxima verificamos se eles não são iguais, se são menores, se são maiores, se são iguais e assim
por diante.
Portanto, se tivermos dois registros, estaremos comparando com outro registro que não seja igual a zero.
Ok, o registro pode ter o valor zero, mas, mesmo assim, ele seria comparado com esse registro.
Ok, vamos ver como diríamos isso em voz alta.
Então vamos lá.
Temos o if, depois temos o zero e agora voltamos à condição mais uma vez, exatamente da mesma forma.
Então, acho que devo parar de falar durante isso.
Agora vamos fazer isso mais uma vez.
Se V zero for maior que v um, saltamos para essa condição.
Portanto, se tivermos dois registros, faremos isso dessa forma.
E isso nos dará a seguinte declaração, que está correta.
Portanto, se b zero for maior que V um, chegaremos a essa condição.
Caso contrário, seguimos em frente ou avançamos em nosso código e, sim, talvez não vá para o rótulo ou talvez a função esteja
retornando lá.
Não temos ou não é necessário ter um rótulo de "ir para".
Também é importante ter isso em mente.
Tudo bem.
Aqui está.
Exatamente o mesmo.
Se desta vez não tivermos o valor zero, teremos apenas igual, diferente, menor ou maior
e nossos registros e as condições para as quais saltamos.
Então, sim, eles são exatamente iguais, além do fato de que temos outro registro e não comparamos
com o valor zero.
Tudo bem.
Da última vez, foi um pouco confuso.
Vamos ver se essa abordagem é mais fácil para você.
Então vamos ver.
Temos nosso método de colisão de métodos.
Ele está retornando vazio.
E, no lado esquerdo, temos o código Java, portanto, temos o registro local.
Não sabemos se está na variável ou no espaço reservado para o valor na primeira linha, podemos ver, desculpe,
na linha 38, podemos ver que estamos obtendo ou sim, estamos buscando esse objeto, esse ponto vive e colocando-o
em v zero.
Em seguida, fazemos nossa comparação.
Portanto, diga isso em voz alta.
Se o zero for maior que zero, passaremos para a condição zero.
A condição zero está aqui.
Portanto, pulamos essa parte, esse código abaixo, até chegarmos a essa condição.
Então, estamos somando e menos um, o que significa que estamos subtraindo e valorizando.
Portanto, bastante ridículo, mas não importa.
E então colocamos esse valor de volta em nossa vida.
Portanto, estamos subtraindo um de nossas vidas.
Ok, essa é a nossa declaração verdadeira.
Caso seja uma afirmação falsa, estamos seguindo em frente até chegarmos a esse rótulo de destino e, em seguida, passamos para
o rótulo de destino.
A propósito, na primeira vez, esqueci de mencionar que pulamos esse go to na linha 56, mas você deve estar familiarizado
com isso.
Tudo bem.
Está bem.
E vamos fazer a comparação com relação ao código à esquerda.
Interessante.
Nossa declaração if é diferente, pois estamos comparando se essa vida é menor que zero.
Mas à direita e em nosso código de sorriso, temos uma condição e vice-versa.
Falamos sobre isso no vídeo e, mais uma vez, estamos com ele da mesma forma agora.
Então, podemos ver que nossa V0 será inicializada com um e esse será colocado ou referenciado com
o nome da variável blues.
Portanto, estamos colocando um em nosso LUS, que é do tipo booleano.
Isso significa que a perda é igual à verdade nessa linha aqui.
Essa é a nossa parte azul.
Tudo bem.
E esses são nossos dois casos.
A primeira, se a declaração if acima for verdadeira, subtrairá uma vida da vida do jogador e retornaremos.
Ignoramos isso, vamos e voltamos.
E se a nossa declaração na linha 40 for falsa, seguiremos em frente e definiremos o nome da nossa variável como o
valor.
Verdadeiro.
E sim, é isso.
Depois disso, vamos para esse rótulo e retornamos para fora dessa função.
Tudo bem.
Se fizermos isso na parte do smiley, poderemos ver isso aqui.
É assim que ele se parece.
E podemos ver mais uma vez que a parte do smiley é diferente da parte do Java.
E também é o que o Android está nos dizendo ou nos lembrando.
Portanto, não se atenha ao código Java em relação às instruções if.
Dê uma olhada nisso.
Mas isso pode ser diferente na parte do smiley.
E a parte sorridente é a que importa, porque é a que está sendo executada e a que
podemos corrigir.
Portanto, tente entender a instrução if primeiro e depois tente aplicar o patch.
E não tente adivinhar com números de linha ou coisas do gênero.
Tentei fazer isso e não deu muito certo.
Assim, você perderá muito tempo e ficará um pouco frustrado.
Portanto, tento fazer uma abordagem limpa de engenharia reversa na instrução if que você deseja corrigir.
Então, você estará pronto para começar e perderá menos tempo.
Tudo bem.
Está bem.
Em seguida, queremos continuar praticando, pois essa é a parte mais importante se você quiser aprender de forma inteligente.
Portanto, estendi nosso código e nosso Java e fornecerei isso posteriormente a você.
Não procuramos o código-fonte da parte Java porque isso pode ser ainda mais confuso em relação
às instruções if.
Fazemos nossa abordagem mais uma vez na parte sorridente e, ao fazer isso, também recapitularemos todas as coisas.
Introduziremos talvez novas declarações que não vimos até o momento, pelo menos na tabela e coisas do gênero.
Por isso, continuamos praticando.
E sim, ao fazer isso repetidamente, você se tornará um mestre do sorriso.
Depois deste capítulo, acredite em mim, você será capaz de ler e escrever códigos com sorrisos bonitos e sofisticados.
Está bem.
A parte prática estará no próximo vídeo e isso foi uma espécie de spoiler.
Portanto, estou ansioso para vê-lo lá.