Bem-vindo de volta a Objetos e métodos.
Esta é a última seção do nosso enorme capítulo sobre sorrisos no momento.
E essa também é a parte mais incrível, porque os objetos e métodos nos dão a possibilidade de modificar nosso
código, de modificá-lo para que possamos inserir um código completamente novo em nosso aplicativo.
Quero dizer, tudo bem, fizemos isso em relação à substituição de registros únicos, mas agora podemos adicionar código
adicional e usaremos isso para fazer muitas coisas incríveis.
Por exemplo, inserimos um código que imprime senhas ou chaves criptográficas.
Também podemos definir alguns comandos de impressão para imprimir valores de registros, por exemplo, ou referentes a verificações.
Portanto, se essa verificação tiver sido definida como verdadeira ou falsa, poderemos fazer muitas coisas.
Vamos nos aprofundar no assunto e você verá como ele é incrível.
Tudo bem.
Portanto, vamos começar com um exemplo simples à esquerda.
Deixe-me pegar esse mouse.
Aqui está.
Temos nosso cheque se perdermos a função.
E este aqui tem uma variável local chamada collision.
Estamos criando um novo jogador e esse jogador chama agora essa função de colisão e essa colisão retorna um valor booleano,
verdadeiro ou falso?
E então retornamos esse valor aqui.
E se esse valor for, por exemplo, verdadeiro, então perderemos.
Caso contrário, o jogo pode seguir em frente.
Tudo bem?
Desta vez, não estamos muito interessados nessa função aqui.
Estamos interessados principalmente neste, o jogador.
Então, como esse objeto é criado?
E se você der uma olhada à direita, temos o código do smiley e podemos ver que temos uma nova instância
que zeramos.
Em seguida, temos a referência a essa instância e esta é a referência da classe ao player.
Podemos ver isso no final, no ponto e vírgula aqui.
Em seguida, temos uma chamada de método direto invoke e agora também precisamos cuidar de detalhes como esses
colchetes.
Essa conta invocou esse método nesse objeto, e o método que vamos invocar é o ponto do jogador de
referência da nossa classe.
Init é um construtor, portanto, não escrevemos um construtor ou não definimos um construtor aqui na classe
do jogador.
Quero dizer, você não pode ver isso, mas pelo menos haverá um construtor padrão.
Veremos isso se codificarmos isso mais tarde, bem rápido.
Está bem.
E, neste ano, esse construtor é chamado e retorna void, e agora podemos chamar métodos nesse objeto,
o que é incrível.
Digamos que, sim, o objeto de exibição tenha alguns métodos diferentes.
Agora podemos estender esse código chamando métodos adicionais aqui.
Super agradável.
Tudo bem, podemos ver.
Ok, isso que zeramos se torna agora uma variável local, que é o player.
Portanto, agora temos nossa variável de jogador.
Mas a parte mais importante são essas duas instruções: nil instance e invoke direct.
Tudo bem, então temos este aqui.
Aqui estamos chamando um método nesse objeto.
Vamos ver como fica.
Está bem.
Desta vez, temos o invoke virtual.
Isso significa apenas que temos um método público de invocação direta.
Você se lembra que isso se refere a construtores e métodos privados.
Invoke virtual é referente a métodos públicos.
Então, temos nossos colchetes e nosso zero e podemos vê-lo novamente.
Referência de classe Colisão de jogadores.
É assim que podemos chamar um método nesse objeto.
Portanto, a abordagem é sempre a mesma em relação aos objetos.
Você também aprenderá sobre métodos estáticos.
Isso é um pouco diferente.
É mais fácil.
Mas, por enquanto, estamos apenas observando os objetos aqui.
Tudo bem?
E então, sim, o resto é bem conhecido.
Movemos o resultado para V um, o que significa que o nosso registro B um agora contém o valor de retorno desse jogador de método
nessa colisão.
E então simplesmente retornamos essa v e também podemos ver essa aqui, que é a colisão da variável
local.
Portanto, ele é atribuído logo antes de retornarmos esse valor.
Mas isso não é realmente importante.
Tudo bem.
E isso é tudo sobre nossa função aqui.
Portanto, se dermos uma olhada no lado esquerdo do código Java, veremos que há muitas coisas
acontecendo e também no lado direito, é claro.
Mas agora, agora somos capazes de entender o que está acontecendo.
Portanto, com relação a essa nova instância e à invocação direta, tudo bem, temos que aprender isso primeiro, mas
faremos isso praticando.
Mas, afinal de contas, este é praticamente idêntico a este.
Esse é apenas outro método, uma bola diferente.
Esse é o construtor e esse é um método de colisão.
Portanto, se você quiser criar um novo objeto de jogador, basta pegar este aqui.
E tudo o que temos que fazer é atribuí-lo a um novo registro.
Então, usamos, por exemplo, queremos isso e também aqui e, em seguida, podemos criar um novo jogador.
Faremos isso no aplicativo de planejamento de espaço mais tarde.
Mas, antes de tudo, vamos mudar para a VM do Ubuntu e codificar esse aplicativo rapidamente, para que possamos
praticar e brincar um pouco.
Tudo bem.
Pronto, agora temos a VM do Ubuntu.
Vamos escrever esse aplicativo.
Então, abrimos o Android Studio.
Está bem.
Portanto, aqui criamos um novo projeto, agora com uma atividade vazia.
E batizamos esse Smiley de três Shabba, e voltamos para Marshmallow.
Tudo bem.
Portanto, vamos esperar até que a compilação do Gradle seja concluída.
Isso pode levar alguns minutos, portanto, vejo você em alguns instantes.
Muito bem.
A construção foi concluída.
Este é o nosso aplicativo.
Agora vamos criar uma nova classe.
E sabe de uma coisa?
Nomeamos esse jogador mais uma vez.
Portanto, é realmente impressionante a diversidade que eu trago para isso agora.
Mas ter esse nome de classe, quero dizer, esse é o melhor exemplo, em minha opinião, para praticar isso.
Então, neste momento, vamos fazer um sim, vamos fazer um pouco diferente.
Portanto, agora temos um nível completamente diferente e começamos com o nível um, mas ainda temos o nível de potência e acho
que ficamos um pouco mais fortes.
Portanto, agora nosso nível de potência é de, digamos, 5050 escolas.
E, desta vez, você também cria um construtor.
Então, acho que essa é a primeira vez que criamos um construtor aqui.
Portanto, acho que não podemos mais reclamar de alguma diversidade em nosso aplicativo aqui.
Imprimimos que criamos um novo objeto e isso é tudo.
Então, temos dois métodos no public void.
Vejamos, temos o método level up aqui, o nível desse código e isso aumenta nosso nível em um.
E também imprimimos nosso novo nível aqui.
Muito bem, então temos um novo método diferente, outro método que é o aumento da potência.
E temos o parâmetro de poder e aumentamos nosso poder com isso.
E também imprimimos isso.
Tudo bem.
Isso parece bom.
O código relacionado a isso será enorme.
Então, nós o reproduzimos no arquivo somali.
Não será divertido dar uma olhada nisso agora.
Aprenderemos a fazer isso, mas ainda não.
O que nos interessa é o que nos interessa.
Interessado em.
Sim, acho que isso está correto.
É assim que podemos criar um novo objeto.
Então, vejamos, vamos para o nosso main e aqui criamos um novo player
e alguns métodos.
Então vamos ligar.
Aumente a potência e forneceremos um novo que é 900 OC.
Não chamamos o outro método, mas este sim.
Sim, isso é bom para nós.
Tudo bem.
Criamos esse aplicativo e depois o instalamos.
Damos uma olhada rápida nisso, depois descompilamos e analisamos essa mágica.
Portanto, a abordagem é praticamente a mesma e, desta vez, tentamos inserir um novo código aqui, o que,
sim, será incrível.
Então, vejamos, temos nosso aplicativo e vamos colocá-lo em um diretório extra.
Portanto, temos aplicativos.
E não temos absolutamente nenhuma estrutura, ou pelo menos eu não tenho absolutamente nenhuma estrutura lá dentro.
Então, vamos chamar isso de Smiley 3, caso você tenha percebido.
Melhor ainda, escreva-me uma mensagem sobre como organizar isso um pouco.
Talvez eu ajuste isso no futuro.
Então, nós o inserimos e depois o compilamos.
Agora vamos instalá-lo primeiro.
Vamos ver como isso funciona.
Sim.
O ADB está ausente.
Está bem.
Talvez tenhamos que nos conectar primeiro.
Estamos nos conectando primeiro.
Agora estamos instalando esse aplicativo.
Obtemos a tela e também um novo terminal para buscar a saída.
Portanto, no passado, vimos que a produção da Lochhead é realmente enorme.
Portanto, filtramos isso agora mesmo e podemos fazer isso com grep i para ignorar k sensível.
E estamos procurando instruções de saída do sistema.
Abrimos nosso aplicativo.
Aqui está.
Sim, temos um hello world, mas é nisso que estamos interessados.
Um novo objeto de jogador foi criado.
Nenhum tipo.
O novo nível de potência agradável é 900.
Acho que a frase poderia ter sido gramaticalmente um pouco melhor, mas está tudo bem para nós.
Então, sim, criamos um novo objeto de jogador e aumentamos o nível de poder.
Então, vamos dar uma olhada no código múltiplo e ver como essa parte se parece e, portanto, eu me livro de
todas essas janelas.
E descompilamos o ativo e o abrimos com os resultados para as classes do editor de código.
Muito bem, subam.
Vamos dar uma olhada nesse lugar, Smiley.
Então vamos ver.
Está bem.
Vamos começar do início.
Portanto, temos nossa classe pública, nossa classe de jogador.
Não estendemos uma determinada classe especial.
Portanto, temos uma superclasse do Java, um objeto.
Esta é a fonte.
Temos dois campos de instância aqui e não os víamos há muito tempo, mas é bom vê-los.
Então, temos nosso construtor e agora temos algum código em nosso construtor aqui e
aqui podemos ver, bem, ok, não esperava que fosse tão grande, mas isso parece realmente difícil agora.
Portanto, quero dizer, aumentar a potência.
Vamos dar uma olhada.
Tudo bem.
É apenas essa, essas duas linhas aqui, e essas duas linhas geram essa quantidade de código de sorriso.
Aprenderemos a lidar com isso.
E não será ou não será tão complexo.
Mas, por enquanto, isso também é o nível acima.
Está bem.
Vamos dar uma olhada em algo mais suave.
Portanto, a atividade principal, essas duas janelas, aumenta ainda mais.
Tenho essa sensação.
Está bem.
Portanto, aqui temos nossa atividade principal e estamos interessados apenas nesta parte aqui.
Então, a propósito, isso está aqui.
Se olharmos para isso.
Portanto, esse é o ponto zero em que estamos.
Estamos obtendo esse valor como sendo zero.
E aqui temos o invoke virtual.
Portanto, estamos invocando esse código de método e esse tem um parâmetro inteiro.
Portanto, ele é referenciado como um número inteiro.
Mas, sim, é algum tipo de referência.
Portanto, se você estiver curioso e quiser saber o que é esse.
Portanto, esse é o parâmetro de exibição de conteúdo definido, que é.
E este aqui.
Portanto, essa identificação.
Tudo bem.
Portanto, pelo menos não é uma referência.
Esta é uma identificação aqui.
Desculpe, não tenho um endereço.
Essa é uma identificação.
Está bem.
Mas isso não é algo que nos interessa no momento, portanto.
E vamos pular essa parte.
E sim, agora vamos nos concentrar apenas nessa parte.
Então, pego meu tablet gráfico e discutimos essas poucas linhas.
Pessoal, vamos dar uma olhada neste código aqui.
Tudo bem.
A primeira linha já é uma nova instrução.
Vamos ver o que isso faz.
Nova instância.
Então, temos um registro com zero.
Temos uma referência de tipo capital até jogador e, em seguida, temos nosso ponto e vírgula.
Portanto, temos o tipo de jogador.
Certo, vamos pegar nossa folha de dicas ou, sim, a folha de dicas do código do smiley up e dar uma olhada.
Vamos dar uma olhada nessa instrução.
Espero que você tenha sua folha de dicas ao seu lado, pois precisaremos dela muitas vezes durante este capítulo
e também nos últimos vídeos.
Portanto, essa folha de dicas é muito importante para nós.
Está bem.
Portanto, estamos procurando uma nova instância.
Nova instância.
Está bem.
Nós temos.
Temos apenas esses dois.
Ok, isso é bom.
Nova instância, v x e, em seguida, temos o tipo de vírgula, instanciamos um tipo de objeto e colocamos a referência da
instância recém-criada no tipo.
Bem, tudo bem, há muita coisa acontecendo nessa instrução aqui.
Vamos ler isso mais uma vez, mas vamos fechar aqui.
Instâncias, é um tipo de objeto, então, ok, esse é o nosso tipo de objeto e coloca a referência da instância
recém-criada.
Estamos criando uma nova instância e colocamos a referência em v x.
Vamos dar uma olhada no exemplo.
Talvez entendamos isso um pouco melhor aqui.
Portanto, temos uma nova instância que zeramos e, em seguida, temos um fluxo de entrada de arquivo Java IO.
Portanto, estamos criando uma nova instância do fluxo de entrada de arquivo Java IO e colocando-o em V zero,
o que é incrível.
Por quê?
Porque agora temos uma instância de fluxo de entrada de arquivo.
Podemos, por exemplo, usar também o fluxo de saída de arquivo e podemos usar essa instância agora para registrar informações
confidenciais.
Vamos supor que tenhamos obtido o método de criptografia e descriptografia de A.
Agora podemos usar essa instância aqui, que é pensada e com zero, para bloquear informações confidenciais, como
a senha, o vetor de inicialização para criptografá-la ou talvez também a mensagem descriptografada.
Também podemos usar isso para criar um novo código em nosso aplicativo, para que possamos criar uma nova instância do que
quisermos.
E esse é incrível porque o usaremos para inserir instruções de depuração para imprimir valores de registro, para verificar
qual instrução if estamos usando, qual caminho estamos seguindo nesse aplicativo e muitas, muitas
coisas incríveis.
Está bem.
Mas, primeiro, temos que entender como podemos trabalhar com isso.
Tudo bem.
Portanto, vamos nos afastar um pouco.
Então, vamos voltar ao nosso código.
Está bem.
Portanto, este aqui é o nosso tipo de objeto.
Tipo de objeto.
Portanto, estamos instanciando um novo tipo de objeto.
Portanto, jogador.
E estamos colocando a referência dessa instância recém-criada.
Portanto, estamos tendo uma referência.
Dessa instância recém-criada.
E estamos colocando isso em v zero.
Esse jogador agora é colocado em v zero.
Tudo bem.
Essa foi uma frase curta, mas muitas coisas foram pensadas ali.
Isso significa que estamos tendo essa linha, nosso tipo de objeto.
Estamos criando uma nova instância e colocamos a referência em v zero.
Está bem.
Mas não fazemos mais nada.
Portanto, nesse caso, não podemos usar algo como, por exemplo, o poder de ponto do jogador.
Isso não é possível.
Por quê?
Porque ainda não chamamos o construtor.
Temos apenas uma referência desse objeto.
Portanto, isso é apenas uma referência, nada mais.
Esse objeto ou instância não é inválido no momento.
Está bem.
Portanto, acho que ele se tornará um na próxima linha, talvez.
Vejamos.
Portanto, estamos aqui.
Portanto, sabemos invocar diretamente em relação a métodos ou construtores privados.
Está bem.
Invoque diretamente.
Depois, temos esses colchetes curvos aqui, o que é interessante porque não os vimos aqui,
por exemplo.
Parece ser uma nova invocação direta.
Em seguida, temos nossa referência de tipo ou, neste caso, também temos nossa referência de instância porque
temos esse erro aqui.
Isso significa que esse é um ponto.
Portanto, nosso B zero precisa ser nosso jogador.
Portanto, nesse caso, o jogador tem um ponto a favor.
Mas antes de fazermos muitas suposições, vamos dar uma olhada nisso.
O que essa instrução faz.
Estamos procurando diretamente em grandes quantidades.
Ok, temos seis acertos.
Portanto, invoque parâmetros diretos.
Chamada de método.
Invoque o intervalo de barra direto e invoque o vazio direto.
Está bem.
Portanto, este é definitivamente o que estamos procurando.
Invoque diretamente.
Então, temos parâmetros e temos um método chamado que invoca um método com parâmetros sem resolução
de método virtual.
Está bem.
Portanto, se você não se importar com este aqui, o que faremos agora é simplesmente invocar um método
com parâmetros.
Isso não parece tão difícil, mas vamos dar uma olhada no exemplo.
Invoque o direct v one.
Em seguida, temos o objeto Java Lang e também esse construtor do objeto Java Lang.
Mas podemos ver aqui que, se este for o método, é um pouco estranho, porque não temos parâmetro
ali e aqui ele nos diz que invoca um método com parâmetros, mas aqui podemos ver que não há parâmetros
ali.
Então, vamos ler um pouco mais.
Temos esse método de aparência estranha.
Eight invoca o método eight na tabela de métodos, portanto, não tenho certeza do que se trata.
Portanto, simplesmente ignoramos isso com apenas um parâmetro e queremos que essa instância esteja correta.
Isso significa que queremos o nosso parâmetro, mas queremos a nossa instância.
Portanto, não temos um parâmetro aqui.
Isso agora é como o registro P zero.
Se você tivesse um parâmetro aqui, teríamos um segundo registro ali.
Portanto, o primeiro registro entre colchetes de invoke direct significa que esta é a instância deste
nosso objeto.
E, em seguida, haverá todos os outros parâmetros relacionados à chamada da função.
Mas isso agora está vazio porque só temos esse objeto aqui.
Isso é bastante semelhante ao registro P zero no momento.
Está bem.
Portanto, é absolutamente normal que você esteja um pouco confuso.
Mas se você fizer nossa própria chamada de método ou a próxima chamada de método, verá o que quero dizer.
Ok, então vamos voltar a habilitar nossa correspondência, o texto escrito aqui.
Quero dizer, está ficando um pouco estranho, mas aqui está tudo bem.
Portanto, isso significa invocar diretamente.
Estamos invocando o construtor.
Este aqui é o nosso objeto.
Portanto.
Isso significa que esse objeto é o jogador porque tem v zero.
Portanto, eu escrevo isso como follow player e, em seguida, temos um ponto e esse método init.
Mas esse método init está entre chaves, o que significa que ele não é um método real em nosso
código Java.
Portanto, se você der uma olhada nisso, se criar um novo objeto de jogador, ele terá apenas esta linha
aqui.
E sim, isso também é o que temos em nossa parte sorridente na primeira linha.
Mas em nosso objeto de jogador, também temos este aqui.
Esse é agora o nosso construtor que imprime um novo objeto de jogador que foi criado.
E esse construtor agora é exatamente o que está acontecendo nessa linha.
Portanto, esse foi o motivo pelo qual fui tão, tão preciso ao ler essa instrução da Mali.
Até o momento, não temos nosso sistema. fora. println.
Isso acontece neste momento, mas não é uma instrução ou função Java que podemos ver em nosso
código.
Isso está oculto.
Portanto, se você der uma olhada na atividade principal, não temos isso aqui.
Temos isso incluído neste, mas não há instruções específicas para isso.
Em somali, podemos ver isso.
Então, este aqui é como em Matrix, onde podemos ver o código.
O que realmente está acontecendo nesse caso é que podemos ver que estamos criando uma nova instância e, em seguida,
o construtor dessa instância.
E sim, é um pouco confuso, mas essa parte é sempre a mesma.
Estamos criando uma nova instância e, em seguida, invocamos diretamente o construtor, caso
ele tenha alguns parâmetros.
Eles serão, é claro, incluídos aqui.
Mas vamos fazer isso passo a passo e não torná-lo muito complexo neste momento.
Ok, então vamos voltar a esse caso.
Isso significa que temos nosso player nele, mas ele não é mencionado no código Java.
Portanto, não vemos isso.
Pelo menos estamos na matriz aqui e na parte somali.
Assim, podemos ver tudo.
Está bem.
Portanto, essa linha não tem um determinado valor Java aqui.
Portanto, esses dois acabarão nessa linha.
Está bem.
Portanto, temos este e este.
Em seguida, limpe isso.
Este é familiar.
Localmente, zero significa que temos uma etiqueta para o nosso registro.
Agora mesmo.
Ele se torna uma variável ou um objeto nesse caso, e esse objeto é chamado de player.
Mas somos muito inteligentes e já o nomeamos como jogador, portanto, também terminamos com ele.
Portanto, essas três linhas estão claras agora.
O próximo também tem a barra 16 V e depois esse valor.
Portanto, neste momento, estamos escrevendo B um ou estamos escrevendo esse valor em v10x384.
E esse é o valor.
Vamos fazer as contas.
Está bem.
São 900.
Eu realmente espero que seja 900.
Caso contrário, terei que gravar esse vídeo novamente.
Muito bem, vamos ver.
Sim.
Também temos essa linha aqui.
Ok, em seguida, invocamos virtual e isso significa que estamos invocando um método virtual, que é um método público.
Portanto, invocamos diretamente os métodos e construtores privados.
Invocamos o virtual em relação aos métodos públicos e, em seguida, invocamos o estático.
Portanto, os métodos estáticos são bastante semelhantes em relação a ambos, mas um método estático não tem essa seta
aqui que indica que agora é um campo de instância ou método de instância porque o método estático
não tem uma instância.
Falaremos sobre métodos estáticos em uma seção separada, mas esses são os três tipos com os quais temos que
lidar.
E não é tão complicado assim.
São apenas esses três: invoke direct, invoke virtual e invoke static.
Então, vejamos, invoque o virtual.
Estamos tendo um método público.
Sabemos que este aqui é o nosso objeto.
Isso significa que agora temos um parâmetro aqui.
Vejamos.
Temos poder de aumento.
Esse é o método ou o método de instância.
E, sim, obtivemos o parâmetro aqui do tipo integer.
Ok, estamos retornando ao vazio.
É bom saber disso.
Então, vamos analisar isso mais uma vez.
Invocar virtual.
Estamos chamando um método público.
Temos nosso objeto this ou this object é do tipo player.
Então, sim, não precisamos escrever isso.
Também obtivemos um parâmetro em nossa invocação de método e é isso que queremos e queremos que seja passado como
parâmetro aqui.
Então, eu limpo isso rapidamente.
Agora podemos ver isso um pouco melhor.
É isso que queremos, mas para ter certeza.
De qualquer forma, vamos dar uma olhada nisso.
Portanto, estamos procurando invocar melhor.
Está bem.
Aqui podemos ver que temos oito acertos, portanto, invoque os parâmetros virtuais entre colchetes.
Código do método.
Isso parece muito promissor, mas, mesmo assim, vamos verificar os outros dois intervalos OC quick e quick range.
Tudo bem.
Este é o nosso método.
O código invoca um método virtual com parâmetros.
Legal.
Essa descrição é fantástica.
Quero dizer, ele nos diz tudo o que podemos entender.
Ele apenas invoca um método melhor com parâmetros, só isso.
Mas vamos dar uma olhada na descrição.
Invoca um método virtual.
Aqui temos antes do zero um, dois, três.
Ok, isso significa que temos um, dois, três, quatro, cinco parâmetros e aqui podemos ver.
Ok, temos o teste dois.
Esta é a nossa instância e o método cinco é o método que estamos chamando, e aqui podemos ver que temos
um, dois, três, quatro.
Está bem.
No início, teríamos ficado confusos, mas agora sabemos que o primeiro registro é o nosso objeto.
Vamos ler isso.
Invoca o sexto método e a tabela de métodos.
Está bem.
Nós nos ignoramos com os seguintes argumentos anteriormente.
Sim, é essa instância e nós zeramos.
Queremos que v dois e b três sejam os parâmetros do método.
O método tem cinco argumentos e força quatro bits mais significativos.
Não importa.
Muito bem, esses são nossos argumentos.
Desculpe.
Esses são nossos parâmetros.
E temos cinco argumentos, incluindo o nosso OC.
Espero não ter tornado as coisas mais complexas.
Então vamos ver.
Nós capacitamos nossos.
Ooh.
Parece um pouco bagunçado no momento.
Isso acontecia o tempo todo?
Certo.
Talvez seja isso.
Ok, então temos isso.
Esse é agora o nosso parâmetro.
E estamos invocando o aumento do poder.
Isso significa que temos um jogador.
Ponto.
Diminuição.
Potência que
queremos como parâmetro e que queremos como 900.
Tudo bem.
Portanto, neste ponto, criamos um novo objeto de jogador.
Vou limpar um pouco isso.
Está bem.
Muito melhor.
Portanto, criamos um novo objeto de jogador aqui.
E isso é feito chamando a nova instância e invocando diretamente esses dois.
Então, estamos escrevendo um ou esse valor em v um.
Também endereçamos nossa etiqueta para nosso registro.
Quero dizer, eles não estão relacionados a objetos no momento, portanto, nós os ignoramos.
Em seguida, chamamos um método, este aqui, e chamamos esse método com invoke virtual.
Em seguida, fornecemos esse objeto e zeramos esse registro.
Em seguida, fornecemos nossos parâmetros e temos nossa referência de tipo desse objeto, que termina com o ponto
e vírgula.
Em seguida, temos nosso erro, que sinaliza.
Agora temos nosso método de instância e o método de instância é chamado de increased.
O Power tem um parâmetro aqui e retorna nulo.
E é exatamente isso que essa linha aqui faz.
Tudo bem.
Portanto, essas duas linhas representam um novo jogador e aumentam o poder do jogador em relação às três linhas sorridentes
a seguir.
Este aqui.
Este e este.
Portanto, é assim que podemos criar um novo objeto e também chamar um novo método.
Então, vamos recapitular isso rapidamente nos slides e, em seguida, escreveremos nosso
primeiro código de smiley, porque nossa instância de jogador tem outro método, este aqui, e esse método nunca será usado em
nosso código.
Não o estamos chamando em nosso aplicativo, mas corrigiremos o aplicativo para que chame esse método.
Portanto, escreveremos nossa primeira linha de smiley real com base na inserção ou execução de uma nova chamada de função em nosso aplicativo.
Está bem.
Mas, primeiro, vamos voltar aos slides.
Está bem.
Portanto, essa é uma função diferente, mas isso realmente não importa.
Portanto, a abordagem de criar uma nova instância e chamar um método de instância é sempre a mesma.
Aqui podemos ver que esse método verifica se perdemos retornos e valores booleanos e não tem parâmetro.
Então, estamos criando uma nova instância aqui.
Nova instância também do tipo player.
Está bem.
Portanto, também temos esta frase aqui, copiada deste site incrível, que instancia um tipo de objeto
e coloca a referência da instância recém-criada no VIX OC.
Nosso V0 agora está mantendo nossa referência a essa instância.
Em seguida, temos o invoke direct que invoca um método com parâmetros sem a resolução do método virtual.
Ignoramos tudo o que vem depois de without e damos uma olhada nessa invocação direta, depois nos colchetes, nos parâmetros
e no núcleo do nosso método.
Então, para criar um novo objeto, precisamos apenas das duas linhas a seguir.
Eles criam um novo objeto e o armazenam em v zero.
Agora temos que ser zero registro.
E se quisermos invocar um método nesse objeto, podemos usar o próximo para invocar o virtual em nosso objeto,
que é v zero.
Em seguida, basta escrever L para a referência de tipo do que é esse objeto.
Então, como zeramos esse objeto, depois a seta com ponto e vírgula e o nome do método.
Se você tiver alguns parâmetros, precisaremos declará-los em invoke virtual neste ponto.
Mas, nesse caso, podemos ver que nenhum parâmetro é necessário.
Portanto, sugiro que voltemos ao nosso código e aqui escrevamos nossa primeira linha do Smiley.
Portanto, queremos chamar um novo método de instância.
Vamos ver se conseguimos fazer isso.
Portanto, temos nosso código aqui e agora queremos escrevê-lo da seguinte maneira.
O ponto do jogador sobe de nível.
Queremos ter esse código posteriormente em nosso aplicativo.
Agora podemos escrever essa compilação no aplicativo e pronto.
Sim.
Portanto, vamos supor que não temos o código-fonte aqui e não podemos simplesmente adicionar código Java.
Portanto, precisamos voltar ao nosso bloco de sorrisos.
Muito bem, então vamos ver, vamos fazer algumas anotações.
Nosso método é de nível superior, não tem parâmetros e estamos retornando um vazio.
Portanto, essa é a nossa definição de função.
Vejamos.
Portanto, a primeira coisa que precisamos fazer é criar uma nova instância.
Mas, nesse caso, já temos nossa instância porque essas duas linhas aqui criaram nosso objeto de jogador e o
armazenaram em v zero.
Ele ainda não foi sobrescrito, portanto, podemos simplesmente usar este.
Está bem.
Se você quiser chamar um novo método, será necessário usar.
Sim.
Invocar virtual para métodos públicos.
Talvez tenhamos que declarar também aqui.
Vamos fazer isso da seguinte maneira.
Está bem.
Portanto, invoque o virtual.
Está bem.
Então, podemos ver que não temos nenhum parâmetro ali, mas precisamos do nosso objeto this e o nosso objeto this está
sendo armazenado em v zero.
Ok, então temos um parâmetro que é V zero, depois temos uma vírgula e agora precisamos digitar a referência do
nosso tipo v zero que começa com este L maiúsculo e depois temos que obter aqui a referência do tipo dessa
classe de jogador para que possamos buscá-la aqui.
Está bem.
Os pontos precisam ser substituídos por barras porque, no Smiley, esses são diretórios.
Está bem.
Portanto, temos nosso jogador e a referência de tipo e terminamos com o ponto e vírgula.
Em seguida, queremos chamar um método de instância, o que significa que temos de adicionar nosso erro aqui e, agora,
basta adicionar a definição da função do nosso método.
Queremos chamar, podemos ver que este aqui se chama level up.
Muito bem, suba de nível.
Podemos ver que não temos parâmetros e estamos retornando.
O quê?
Isso é tudo.
Essa linha executará e aumentará o nível do nosso objeto jogador.
E isso é bom porque, de outra forma, nosso jogador não teria a possibilidade de subir de nível.
E isso é algo que, obviamente, não queremos ter.
Queremos um jogador de bom nível no momento.
Então, vamos ver, vamos reproduzir esse aplicativo e instalá-lo no dispositivo.
Então, aqui estamos de volta.
Eu criei e assinei este aplicativo.
Aqui está o nosso dispositivo e também podemos ver whoops.
Temos o aplicativo antigo instalado.
Portanto, ao abrir isso, criamos um novo objeto de jogo e temos um nível de potência de 900 agora.
Tudo bem, então vamos desinstalar isso e instalar nossa nova versão.
Vamos fazer uma contagem regressiva dramática para ver se nosso jogador sobe de nível.
Portanto, abrirei esse aplicativo em 3 para 1.
Ah, e não importa.
Eu simplesmente o abro.
Sim.
Um novo objeto de jogador foi criado.
O novo nível de potência é 900.
Nosso jogador agora está no nível dois.
Não tínhamos a capacidade de subir de nível nesse aplicativo, mas agora a introduzimos e você pode imaginar
quantas coisas pode fazer agora.
Mas não use isso para trapacear em jogos on-line ou em outros jogos ou aplicativos em que não tenha permissão
para fazê-lo.
Portanto, não me responsabilizo se você fizer mau uso de seu poder recém-adquirido.
Tudo bem.
Nesse caso, eu lhe dou permissão para hackear esse aplicativo.
Portanto, subimos de nível e agora estamos no nível dois.
Mas vamos supor que essa seja uma função que esteja fazendo exatamente o mesmo em alguns outros aplicativos,
ou que aumente nosso poder, nosso ouro, nossa vida, nossa saúde, o que quer que seja.
Então, por que o chamamos apenas uma vez?
Não seria mais divertido em relação a esse aplicativo agora se o chamássemos várias vezes?
Portanto, com relação ao código Java, digamos que, em vez de fazer isso, façamos isso.
Dessa forma, subiremos muito mais de nível.
Mais rápido, certo.
Vamos ver como podemos fazer isso.
Voltamos para o nosso casaco sorridente.
E se você der uma olhada nisso, verá que não temos certos parâmetros ou certas condições
aqui.
Chamamos esse método de instância de nível superior, sem parâmetros.
E tudo isso está dentro desse método.
Entramos em nosso objeto de jogador e ele faz o resto.
Portanto, vamos simplesmente copiar e colar essa linha.
Então, eu o copiei e agora o colamos com um pouco mais de frequência.
Está bem.
Então, vamos reproduzir esse aplicativo novamente e ver como ele funciona.
Então, aqui estamos nós novamente.
Criei essa nova versão.
Podemos ver que o antigo ainda está funcionando.
Vamos desinstalar esse aplicativo de desinstalação do ADB de forma inteligente.
Três ADB instalam o apk estranho e o plano de fundo.
Você pode ver o código ou o código do smiley com todos esses aplicativos de nível.
Devemos colocar uma câmera dramática nisso mais uma vez?
Vamos fazer isso.
Três, dois, um, vai.
E lá vamos nós.
Agora temos muito mais aumentos de nível, o que é incrível.
Portanto, é assim que temos que lidar com objetos e métodos de instância.
Para recapitular isso rapidamente, vamos dar uma olhada.
O que precisamos fazer é criar uma nova instância.
Em seguida, precisamos invocar o construtor dessa instância.
E isso está dentro desses colchetes aqui.
Se o construtor tiver parâmetros, construtor, construtor, construtor, se o construtor tiver alguns
parâmetros, teremos que declará-los aqui.
Digamos que nosso construtor tenha um número inteiro.
Então, precisamos.
É claro que sim.
Então, precisamos introduzir um novo registro aqui.
Por exemplo, b dois.
Este agora tem dez anos.
E também temos um parâmetro conhecido.
Desculpe-me pelo B dois.
Tudo bem.
Portanto, caso ele não tenha nenhum parâmetro, podemos nos ater a essa abordagem.
Certo, então vamos nos preparar para isso.
Portanto, nova instância, invoque diretamente e, em seguida, teremos esse objeto no zero.
Se quisermos chamar um método, um método público, podemos usar invocar a quantidade virtual de parâmetros.
Referência do objeto.
Nossa seta, por exemplo, o método, o método de instância e o protótipo.
E é isso.
Essas três etapas.
Então, deixe-me mostrar-lhe isso da seguinte maneira.
Essas três etapas são necessárias para fazer isso.
Está bem.
Tudo bem.
Então, isso é tudo para este vídeo agora.
No próximo vídeo, daremos uma olhada nos métodos estáticos.
E isso será incrível porque voltaremos ao nosso aplicativo de ping espacial e faremos muitas
coisas engraçadas por lá.
Está bem.
Portanto, estou ansioso para vê-lo lá.