Bem-vindos de volta, amigos.
No último vídeo, quero dizer, foi um pouco louco, mas também nos divertimos muito.
Portanto, fizemos um grande progresso em relação ao nosso treinador.
Mas também encontramos algumas coisas que não sabemos até o momento.
E isso é algo que aprenderemos aqui no momento.
No momento, não sabemos como chamar um método ou criar uma nova instância que tenha uma instância como
parâmetro.
Mas isso é algo que descobriremos agora mesmo.
Então, vamos dar uma olhada.
Bem, aqui temos um item e uma gravação, e o código correspondente se parece com o seguinte.
E esta aqui é a classe do item.
Este não tem nada de sofisticado, mas este aqui tem.
Essa é agora a classe do chefe.
E aqui estamos tendo um problema.
Podemos ver que, no construtor, precisamos fornecer um item e, em relação à nossa abordagem livre, ele se pareceria
com o seguinte.
Portanto, queremos criar um novo objeto de chefe ou uma instância de chefe e, no construtor, precisamos
fornecer esse item agora.
Nossa abordagem, por enquanto, foi a seguinte: obter a referência da classe e criar uma
nova instância com o operador new, como esta.
Mas agora, dentro do novo operador, precisamos fornecer um parâmetro.
E esse parâmetro não é apenas uma cadeia de caracteres ou um valor inteiro, mas agora é um objeto.
E, para ser sincero, isso não é absolutamente nenhuma ciência de foguetes.
Mas acho que precisamos falar sobre isso, que você está familiarizado com toda essa abordagem aqui.
Portanto, o que precisamos fazer é simplesmente criar uma nova instância de item e, em seguida, usar essa instância
como parâmetro aqui.
Portanto, seria o seguinte, criando um novo item.
E então usamos isso como parâmetro para nosso outro novo operador.
Vamos dar uma olhada em como podemos fazer isso em nosso novo aplicativo aqui.
Muito bem, vamos lá.
Então, aqui queremos o VM.
E agora preparei um exemplo diferente.
Vamos dar uma olhada nesse caso.
Quero dizer, está bem próximo do último, mas, mesmo assim, vamos ver.
Portanto, em meu diretório de downloads, temos agora um novo aplicativo e podemos inseri-lo gratuitamente.
Muito bem, vamos instalar este.
E isso é tudo para tirar a tela do smartphone aqui.
Então, agora estamos tendo uma situação completamente diferente em relação a esta, certo?
Com certeza.
Vamos dar uma olhada.
Portanto, agora temos o mesmo aplicativo, mas um pouco diferente.
Temos agora uma postagem aqui, nesta postagem, com alguns HP.
Se você clicar na lista de jogadores, eles perderão uma vida.
Isso é lamentável, mas é assim que o jogo funciona.
Está bem.
Desta vez, se você clicar no chefe, verá que ele também tem alguns pontos de vida.
E se clicarmos dez vezes nesse chefe.
Em seguida, podemos ver um item aparecer.
Agora temos um Sepp não qualificado.
Não me pergunte qual é o conjunto de habilidades aqui.
Acho que isso lhe dá poder ilimitado.
Seja invencível, invisível.
E você também pode.
Agora você também pode atirar em planetas inteiros em vez de apenas bolas de fogo.
Portanto, definitivamente queremos ter esse item aqui.
Tudo bem.
A maior parte desse novo aplicativo é apenas para fornecer a você um novo layout sofisticado que não seja muito entediante.
Mas agora vamos dar uma olhada neste aqui e ver se podemos chamar uma instância de chefe.
Tudo bem.
Está bem.
Portanto, a primeira coisa que estou fazendo é colocar esse aplicativo em um novo diretório que posso inserir livremente.
Com um eps o.
Estamos na terceira fileira no momento, portanto, aqui estamos tendo um espaço livre para inserir.
Está bem.
Vamos dar uma olhada nesse caso.
Muito bem.
Dê uma olhada no manifesto do Android.
Aqui está.
Podemos ver ainda uma atividade.
Vamos chamar isso de.
Muito bem, aqui estamos realizando a atividade principal.
Vejamos.
Parece bastante idêntico, como no último exemplo, mas desta vez há uma pequena diferença
aqui.
Portanto, podemos ver que estamos criando um novo objeto de jogador aqui.
Temos a instância do jogador e estamos criando agora um novo objeto de chefe.
E aqui estamos tendo a instância do chefe.
Esse objeto chefe agora tem um objeto como parâmetro.
Portanto, o construtor do chefe está recebendo um item como parâmetro.
E isso é algo sobre o qual não falamos até agora, mas, como já mencionado, não é nada demais.
Vamos dar uma olhada na classe do chefe.
Portanto, aqui podemos ver que temos pontos de contato.
Temos esse item, a queda do item de classe e temos esse poder aqui.
O construtor agora está recebendo um objeto como parâmetro e, sim, ele atribui esse objeto a essa instância.
Campo aqui.
Queda de item.
Tudo bem.
Vamos fazer nossa abordagem básica de liberdade e ver até onde podemos chegar com o conhecimento que já temos.
Portanto, estamos criando ou abrindo um novo arquivo de estúdio e escrevendo.
Acho que essa foi a parte mais engraçada do último vídeo.
Tudo bem.
E vamos ver.
Estamos mudando para JavaScript.
Colocamos isso à esquerda.
Colocamos isso à direita.
E agora queremos criar um novo objeto de chefe.
Portanto, precisamos obter a referência da classe e, em seguida, chamar o operador new.
Portanto, a criação de um novo objeto em Java se parece com o seguinte chefe.
Chefe é igual a novo chefe.
Tudo bem.
Sim.
Portanto, agora nos lembramos das coisas que temos que fazer.
Vou encerrar esse assunto rapidamente.
Então, ainda estamos trabalhando com código Java.
Portanto, precisamos que nosso Java funcione e estamos fornecendo aqui nossa função anônima.
Agora, o que precisamos fazer é entrar primeiro na referência da classe e nesta.
Nessa referência de classe, estamos obtendo a referência da classe principal, portanto, podemos fazer isso criando
uma nova variável aqui, a referência da classe principal.
E então estamos usando o java para obter isso.
Não, chefe.
Está bem.
Agora temos a referência da classe.
Precisamos pegar essa referência de classe junto com o operador new e, em seguida, atribuí-la
a uma nova instância.
Portanto, estamos criando uma nova instância, a instância do chefe.
E este será criado agora usando a referência de classe.
Que é apenas este.
E, em seguida, o novo operador de ponto dólar.
Se você fizer isso agora mesmo, com certeza ele desaparecerá, porque aqui não estamos fornecendo nenhum parâmetro.
Mas o construtor do chefe aqui requer algum parâmetro.
No entanto, vamos ver o que Frieda está nos dizendo.
Portanto, precisamos criar ou nos conectar ao smartphone, e agora começamos a liberar o servidor.
Portanto, dados, temperatura local.
Ops.
Não.
Vamos começar por aqui.
Aqui temos nosso smartphone.
O Freedom Server agora está sendo executado em segundo plano.
Agora, pegamos um novo terminal e nos conectamos a esse processo.
Não sei o nome do pacote no momento, portanto, temos que procurar isso no manifesto do Android.
Aqui está.
O hacking do aplicativo Comm é gratuito para a instância.
Muito bem, vamos levar o smartphone de volta para cá.
Tão livre que você.
E, então, podemos simplesmente anexar esse processo aqui, porque não queremos enganchar e substituir coisas.
Queremos criar uma nova instância.
Portanto, o aplicativo já pode ser iniciado ou pode estar em execução no momento.
Portanto, vamos manter isso em primeiro plano.
E agora vamos ver o que acontece.
Três, dois, um.
Aqui está.
Aqui está nossa seta.
E espero algo como sobrecarga, mas não tenho certeza.
Não dei uma olhada nisso agora, então vamos ver.
Sim, exatamente.
Portanto, Frida está nos dizendo que estamos usando um método, mas esse método não está sendo conhecido aqui.
O Frida tem apenas um método, que é este, e precisamos fornecer essa instância de item como parâmetro.
Está bem.
Portanto, precisamos criar esse item por nós mesmos e, em seguida, podemos fornecê-lo como parâmetro e vamos
fazer isso, talvez comentando esse código rapidamente.
Portanto, ele está desocupando a referência de classe do cargo.
E aqui estamos tentando criar uma nova instância de chefe.
Sem parâmetro que falha.
Muito bem.
Agora vamos ver como criar uma nova instância de item.
Quero dizer, estamos aqui criando uma nova instância de chefe.
Portanto, essas etapas são absolutamente idênticas.
O que precisamos fazer é obter a referência a essa classe de item e obter a referência da classe de item.
Portanto, aqui temos nossa variável de referência de classe de item e esta está sendo atribuída ao Chabad
de uso.
Agora, vamos ver que estamos realizando a atividade principal.
Temos algum item?
Acho que podemos clicar duas vezes nesse caso.
Sim.
Então acabamos aqui.
Tudo bem.
Portanto, essa é a referência à nossa classe de item e podemos ver que esse item tem algum parâmetro no construtor.
Portanto, precisamos considerar este aqui.
Mas, quero dizer, o inteiro está no parâmetro.
Isso não é nada demais.
Então, ops.
Portanto, estamos obtendo esse item de referência de classe.
Tudo bem.
E agora estamos criando uma nova instância de item, e podemos criar isso usando o ponto de referência da classe e, em
seguida, dollar new.
E, desta vez, temos um parâmetro de número inteiro.
Portanto, podemos atribuir um novo poder de item e vamos fazer isso desta forma.
Tudo bem.
Agora temos essa instância e podemos aplicá-la agora mesmo a esse novo operador como
parâmetro.
Portanto, ao fazer dessa forma, isso deve funcionar agora mesmo.
Portanto, aqui estamos criando um novo item e aqui estamos obtendo a referência da classe do chefe.
Vamos mudar para este aqui rapidamente.
A referência da classe Boss e estamos usando o novo operador agora com nossa instância recém-criada
aqui.
Legal.
É assim que podemos lidar com os parâmetros complexos na liberdade.
Vamos ver se isso funciona.
Então, vamos copiar isso.
Talvez possamos criar este.
E agora vamos ver.
Colei este código aqui.
Ou seja, posso manter o smartphone no patch de primeiro plano.
E esse objeto recém-criado não aparecerá na tela aqui porque não
foi vinculado a ela.
Está bem.
Tudo bem.
No entanto, devemos ver algumas saídas do ADB loggerhead, então vamos dar uma olhada rápida.
Sim.
Devemos ver este resultado.
Foi criado um novo chefe.
Tudo bem, então vamos também retirar nosso anúncio do AdBlock.
Ops.
De repente, cliquei nesse player.
Portanto, aqui temos nosso bloqueio de BD.
E agora vamos observar tudo isso juntos.
Está bem.
Estamos criando uma nova instância de chefe e três até uma.
Desculpe.
Havia alguns.
Agora um.
E vamos lá.
Foi criado um novo chefe.
Legal.
E também podemos ver que não temos nenhum erro aqui.
Portanto, isso deu certo.
Incrível.
Portanto, é assim que podemos lidar com parâmetros mais complexos.
Portanto, se você não estiver lidando apenas com valores inteiros, como aqui, agora também
podemos criar novas instâncias e usá-las para chamar métodos mais complexos.
Muito bem.
Está bem.
Incrível.
Vamos criar mais alguns chefes aqui.
E ele tem estoque ou.
Tudo bem.
Isso pode não funcionar no momento, mas, mesmo assim, esses ônibus estão sendo criados.
Sabe de uma coisa?
Vamos descobrir se eles realmente existem.
Vamos obter a memória do aplicativo para essas instâncias de barramento agora mesmo para que possamos fazer isso.
Encerro esta porque é um pouco perturbadora.
Quero dizer, podemos fazer isso diretamente depois aqui ou.
Não, vamos acioná-lo.
Sim, vamos acioná-lo.
Separado.
Separado deste aqui.
Portanto, o Java dot perform.
Agora vamos ver se conseguimos encontrar essas instâncias de chefe recém-criadas.
Portanto, desta vez, precisamos examinar a memória do aplicativo aqui e identificar essas instâncias.
Portanto, temos que usar o Java para escolher.
E aqui temos nossa referência de classe.
Desculpe, o mouse à direita e aqui estamos com nossos retornos de chamada.
A referência da classe OC neste caso pode ser copiada e colada daqui e esta é a nossa classe chefe.
Essa é agora a classe em que queremos encontrar todas essas instâncias e aqui temos que fornecer nossos retornos de chamada.
Portanto, clique duas vezes.
Entre colchetes, digite.
Assim, não bagunçaremos todos esses colchetes.
Está bem.
Estamos realizando uma função no jogo.
Aqui estamos tendo a instância.
Se tiver sido encontrado um e estivermos imprimindo isso, uma nova instância de PDV foi identificada e identificada.
Está bem.
E, em seguida, vírgula e a segunda chamada de retorno quando concluída.
E este está sendo chamado de arrependido.
E este está sendo chamado quando a memória do aplicativo termina a varredura.
Em seguida, a varredura da memória do aplicativo para ambas as instâncias.
Portanto, não tenho certeza se este aqui está gramaticalmente correto, mas quero dizer que está na saída de depuração, então,
para mim, está bom.
Está bem.
Vamos remover os espaços.
Sim.
Isso parece um pouco melhor.
Está bem.
Então, agora vamos levar isso para a nossa linha de comando livre aqui e ver se conseguimos encontrar todas essas
instâncias de caixa ocultas.
Então vamos ver.
É isso aí.
Sim.
Portanto, a cabeça do AdBlock pode faltar um pouco em relação à saída, porque aqui podemos ver que temos
muitas instâncias de PDV no momento e também podemos ver qual instância de PDV, por exemplo, tem um determinado nível
de potência.
Se voltarmos atrás.
Quero dizer, isso não é necessário no momento, mas pode ser útil.
Portanto, o POS original tem esse nível de potência definido como 9000.
Portanto, vamos ver se conseguimos identificar o PDV original aqui.
Podemos fazer isso simplesmente usando uma instrução if.
Se o poder de ponto da instância for igual a 9000, então podemos dizer que sim, vamos copiar este.
A instância da postagem original foi identificada e, então, podemos excluir esta aqui.
Caso contrário, estaremos identificando uma instância aleatória de POS.
Sim.
Isso deve funcionar.
A menos que tenhamos fornecido.
Não.
Se você tivesse fornecido 9.000 como energia aqui, isso não teria funcionado.
Mas deve haver apenas uma instância de chefe com esse valor disponível.
Então vamos ver.
Tudo bem.
Aqui temos um resultado diferente.
Esta é a instância original do chefe.
Assim, entre essas instâncias obscuras de golpes e chefes, temos esta aqui.
Este é o nosso original.
Ok, incrível.
Vamos terminar de comentar o script aqui.
Vou avançar rapidamente e depois vamos recapitular os slides.
Tudo bem.
Está bem.
Portanto, aqui temos o script elogiado.
A propósito, quero dizer, não usamos essa instância, mas é claro que agora também podemos acessar todos esses
campos.
E, por exemplo, podemos definir essa instância de PDV para ter pontos de vida e esse valor.
Mas, quero dizer, essa instância do chefe não ocorre na nossa tela aqui, portanto, é absolutamente
inútil.
Tudo bem.
Está bem.
Vamos recapitular isso rapidamente nos slides.
Está bem.
Portanto, aqui temos essas etapas que precisamos executar se quisermos ter uma instância como parâmetro.
Quero dizer, é muito fácil.
Estamos apenas criando uma nova instância do tipo desse parâmetro e, em seguida, fornecemos essa instância
recém-criada como nosso parâmetro.
Isso é tudo.
Estas são as etapas aqui, a primeira e a segunda, e esta última está criando uma nova instância de item.
E três, criando uma nova instância de chefe que tem um item como parâmetro.
Estamos usando apenas os recém-criados aqui.
Tudo bem.
Certo, perfeito.
No próximo vídeo, aprenderemos como podemos fornecer uma instância existente como parâmetro.
Mas, pelas coisas que vimos até agora, isso também pode não ser mais tão complicado, certo?
Com certeza.
No entanto, vamos falar sobre isso no próximo vídeo.
Estou vendo você lá.