Neste vídeo, daremos uma olhada no hooking e no construtor.
Quero dizer, isso não é grande coisa, mas é bom saber como podemos fazer isso.
Portanto, quando um objeto está sendo criado, o construtor está sendo capturado e o gancho desse objeto é um pouco
diferente do que aprendemos até agora, mas apenas um pouco, portanto, vamos descobrir isso agora
mesmo.
Então, aqui estamos de volta à VM do Ubuntu e agora vamos dar uma olhada no aplicativo a seguir.
Assim, recuperamos a tela do nosso smartphone.
Tudo bem.
E já brincamos com esse aplicativo gratuito para instâncias.
Este aqui.
Então, aqui podemos ver que entramos em ambas as instâncias e, se atingirmos essa instância do chefe
várias vezes, ela desaparecerá apenas na tela e nosso item aparecerá aqui.
Isso significa que esse item foi vinculado a esse objeto de caixa.
E também podemos ver isso no código-fonte do aplicativo.
Então, se entrarmos no EPS free para inserir e abrirmos isso com a tela.
Então, tudo bem.
Mas depois venha escolher um livre para inserir.
Cortamos essa classe aqui e pronto.
Esse é o construtor dos esportes e podemos ver que ele requer um item.
Essa classe de item pode ser encontrada aqui.
Portanto, clique duas vezes.
É isso aí.
Esse é agora o item.
E da última vez que brincamos com esse aplicativo, criamos um novo item.
E, com base nesse item, criamos uma nova instância de chefe.
Vamos dar uma olhada no modelo gráfico.
Qual é a diferença entre esse tópico da última vez em relação a este, conectando
o construtor aqui?
Tudo bem.
Vamos dar uma olhada.
Está bem.
Portanto, aqui estamos de volta à mesa digitalizadora.
E, da última vez, brincamos com esse aplicativo com o padrão.
Portanto, criamos uma nova instância de chefe, por exemplo, esta aqui, e esta foi a nossa instância de chefe
recém-gerada.
Mas aqui encontramos um problema.
Essa instância de chefe requer um item como parâmetro e esta aqui.
Portanto, também tivemos que criar um novo item primeiro, que pode ser usado como parâmetro para essa instância
aqui.
Portanto, também criamos um novo item, por exemplo, este aqui.
Ok, então essa foi a instância do item recém-gerado e acho que isso tem um parâmetro em relação ao nível de potência
desse item.
Portanto, não tenho certeza.
Mas acho que chegamos a 9000.
Com essa instância recém-gerada, podemos usá-la em nosso construtor aqui, em nosso objeto
boss recém-gerado.
Ah, claro.
E fazíamos isso com frequência.
Portanto, não criamos apenas uma instância de postagem, mas sim uma certeza, talvez dez ou mais.
Então, por toda parte, havia algumas instâncias de postagem e esta, esta, esta e esta.
Portanto, essa foi a abordagem em relação à última vez.
Também brincamos um pouco com os construtores aqui, sem realmente saber disso, mas desta vez queremos
fazer diferente.
O que queremos fazer agora é o seguinte Em vez de criar novos objetos, queremos reescrever
a criação de um objeto, por exemplo, nesta instância de chefe aqui.
E é exatamente isso que podemos fazer ao conectar o construtor.
Deixe-me mostrar o que quero dizer aqui.
E assim, dentro do método de criação de nossa atividade.
Primeiro, estamos gerando um novo item.
E, depois disso, estamos criando essa instância de postagem aqui.
E estamos usando exatamente esse item que criamos aqui.
Está bem.
Agora, não queremos criar um novo chefe.
Queremos interferir ou modificar a criação desse chefe aqui.
Portanto, podemos conectar o construtor de, por exemplo, esse chefe, ou também essa nova geração de itens.
Então, esse chefe aqui aparece na tela.
E se ele acertar dez vezes esse chefe, receberemos de volta nosso item de conjunto de habilidades.
Este aqui.
E isso significa que, se estivermos derrotando esse chefe, queremos ter um item que não tenha o nível de poder.
Por exemplo, 900.
Ele tem o nível de potência 9000.
Está bem.
Portanto, essa é a diferença em relação à última abordagem e a esta abordagem.
Na última abordagem, criamos novas instâncias e agora estamos interferindo na criação de uma
nova instância aqui, e a manipulamos da maneira que desejamos.
Absolutamente incrível.
Certo.
E também não é tão complexo.
Então, acabamos de conhecer algumas palavras-chave novas, acho que apenas uma ou duas.
Mas vamos descobrir isso agora mesmo.
Então, vamos ver como podemos conectar e construir isso.
A criação do New Object com Frieda.
Vamos começar agora mesmo.
Está bem.
De volta à VM do Ubuntu.
Vamos derrotar esse chefe e aqui temos nosso conjunto de habilidades.
Mas esse não é o item que queremos ter.
Queremos ter um item mais poderoso.
Portanto, vamos descobrir como podemos modificar este aqui.
Está bem.
Então, abrimos o editor de código do Visual Studio e vamos dar uma olhada.
Então, tudo bem, aqui temos essa classe de item e podemos ver que esse item tem esse poder de item que está sendo atribuído
a esse telefone.
Portanto, quando estivermos conectando nosso construtor, poderemos observar qual poder de item será fornecido a este
aqui para este objeto, e poderemos encontrar isso na atividade principal.
Então, vamos abrir esta.
Eu.
É isso mesmo.
Em nosso código original, estamos criando um item que tem 1000 como nível de potência OC para que possamos observar e verificar
se o gancho do nosso construtor foi bem-sucedido.
Portanto, aqui devemos ter algum parâmetro em nosso construtor com o nível 1000 e, em seguida,
vamos substituí-lo aqui.
Então, este aqui, sim.
Vamos substituir o nível de potência OC desse item e, em seguida, poderemos pesquisar em nossas instâncias,
as existentes, e identificar esse item.
Sim.
E isso deve, posteriormente, ter nosso novo nível de potência atribuído.
Tudo bem.
É dessa forma que podemos aprovar e verificar se nosso gancho foi bem-sucedido.
E agora vamos nos aprofundar nesse gancho.
Então, colocamos este à direita no outro à esquerda.
E agora vamos ver.
Como sempre, a primeira coisa que precisamos fazer é fechar essa janela de atualização e, em seguida, habilitar
o JavaScript.
Está bem.
E agora estamos lidando com uma classe aqui, então podemos pensar nesse construtor como um método de classe.
Quero dizer, isso pode não estar correto em relação ao termo, mas em relação ao nosso free the hooking,
podemos pensar dessa forma.
Isso significa que precisamos usar o Java para obter essa referência de classe e, em seguida, acessar o construtor
e definir uma nova implementação para ela.
Muito bem, vamos fazer isso.
Portanto, aqui estamos nos conectando ao JDM.
Estamos fornecendo nossa função anônima e aqui temos nosso código.
Portanto, precisamos primeiro obter a referência da classe.
Portanto, nossa referência de classe de item agora é este pacote.
Portanto, precisamos usar.
Ainda nos lembramos desse?
É claro que sim.
Porque tivemos muita prática em relação a esse jogo.
É claro que são os caras do Java.
Tudo bem.
Nome do pacote, nome da classe de pontos.
Vamos ampliá-lo um pouco mais.
Está bem.
Portanto, agora temos nossa referência de classe.
E essa era a pergunta: como podemos acessar esse construtor?
Se você tiver um método aqui, basta usar esse nome de método.
Mas com relação a um construtor, só temos este aqui.
E, portanto, Frieda também introduziu uma nova palavra-chave.
A nova palavra-chave agora está em dólar.
Portanto, com o dollar nele, agora podemos acessar o construtor, que é este na linha sete.
Portanto, tudo o que precisamos fazer é usar esse dólar nele e, em seguida, definir uma nova implementação.
Vamos nos deparar com um problema aqui, mas não sabemos disso agora.
Portanto, vamos enfrentar esse problema juntos.
E não se preocupe, saberemos como consertar isso depois.
Tudo bem.
Certo, então aqui estamos com nossa implementação de inicialização do dólar e agora queremos ter uma nova implementação
e esse é nosso parâmetro ou nosso nível de potência, e podemos fazer um loop sorry e imprimir isso primeiro.
Portanto, precisamos redefinir isso.
Então, vamos imprimir isso.
Item power of the generated or let's say create that instance is and then let's put an equal sign and this parameter.
Então, primeiro vamos dar uma olhada se este aqui está funcionando. Se este funcionar, podemos
estendê-lo e modificar esses valores.
Mas, no início, mantenha a simplicidade.
Portanto, verifique se os scripts básicos funcionam.
Se estiver encontrando alguns erros aqui, não precisaremos fazer uma grande investigação porque
temos apenas essas três linhas de código.
Tudo bem.
Está bem.
Então, agora vamos ver.
Vamos voltar à tela.
Aqui está.
Podemos deixá-la aberta.
Quero dizer, não há problema algum nisso.
Em seguida, precisamos nos conectar ao nosso smartphone e iniciar o servidor gratuito.
Portanto, dentro do registrador de dados dez.
Está bem.
E este está sendo executado em segundo plano.
Animação incrível.
E aqui estamos nos conectando a esse processo.
Portanto, esse é gratuito.
Mas, à medida que você for hackeando, poderá inserir livremente, se bem me lembro.
Não, não me lembro corretamente.
Então, vamos dar uma olhada.
Liberte o intenso.
Sim.
É isso aí.
Tudo bem.
Então vamos ver.
Sim.
Se você colar isso agora neste aqui, veremos que nada acontece.
A razão para isso é que o método ou esse construtor já foi chamado.
Esse objeto existe e, a menos que não estejamos criando um novo, também não veremos essa implementação
aqui.
Portanto, já nos deparamos com um ponto importante.
Se estivermos lidando com construtores, pode ser uma boa ideia fornecer seu script
já no início.
Então, vamos salvar o script aqui.
Seguro como e quando.
Não se trata de um aplicativo de pagamento de espaço.
Esse é gratuito para inserção.
Não tenho um script aqui.
Isso é ridículo.
Mas mesmo assim.
Portanto, este é o construtor, Chase.
Está bem.
Portanto, fechamos esse e agora estamos aplicando o script aqui nos aplicativos para inserção gratuita.
E então temos apenas este e precisamos iniciar esse aplicativo e não queremos que eles façam uma pausa
e aumentem um pouco o tamanho para que você possa ver isso em uma linha.
Aqui está.
Tudo bem.
Então, agora estamos iniciando esse aplicativo, participando do nosso script gratuito.
Ele será retomado.
E então, se o construtor da classe de item receber código, devemos ver esse resultado aqui.
Muito bem, vamos tentar isso.
E aqui está.
Sim, eu assumi o poder da instância criada e assim por diante.
Legal.
Portanto, conectamos esse construtor.
E, para ser sincero, eu teria presumido que haveria um problema aqui.
Portanto, o problema que acho que enfrentaríamos agora é a queda.
Na maioria das vezes, temos um construtor padrão que não tem parâmetros.
Portanto, se dermos uma olhada na nossa saída comercial aqui, podemos ver que temos esse construtor dentro
do parâmetro.
E minha estimativa é que também estamos tendo um construtor sem um parâmetro.
Isso significa que estamos tendo dois construtores e não sabemos qual deles conectar.
Já falamos sobre isso na seção de sobrecarga, portanto, esta não é idêntica.
Portanto, ter o construtor dentro do parâmetro.
Portanto, se você não assistiu a essa parte, dê uma olhada nesta, porque essa é
uma seção muito importante.
Tudo bem.
Mas agora podemos ver que estamos tendo apenas um construtor dentro do parâmetro e, portanto, também não
precisamos sobrecarregar essa função init aqui.
Talvez também possamos descobrir isso clicando no botão de sorriso aqui e tendo esse código de sorriso
agora.
E depois de todo o nosso capítulo sorridente, isso não é mais um grande problema para ler, o que é absolutamente incrível.
Certo?
Então, aqui podemos ver.
Talvez possamos ampliar isso.
Não olhamos para o Smiley há muito tempo, então vamos ver.
Está bem.
E esta é a classe que podemos ver que não estamos estendendo na classe especial aqui.
Temos um poder de item de alimentação de instância.
Temos um nome de campo de instância da string de tipo.
E então temos esse único método construtor aqui, que tem isso nele e aqui podemos ver um parâmetro do
tipo inteiro retornando void.
Portanto, temos apenas um construtor ali.
Portanto, talvez não seja necessário sobrecarregá-lo, se for o caso.
Se precisarmos sobrecarregá-lo, veremos nos slides como podemos fazer isso.
Mas é exatamente a mesma coisa que fizemos nos últimos vídeos.
Tudo bem.
Está bem.
Antes de voltarmos aos slides e descobrirmos como podemos sobrecarregar esse construtor, vamos modificá-lo.
Então, vamos colocar isso de volta à direita.
Está bem.
E vejamos, queremos ter um nível de potência de item superior a mil.
Por exemplo, 9000.
Se você quiser fazer isso por conta própria agora, poderá pausar e retroceder o vídeo mais tarde.
Agora, continuarei com a solução sobre como modificar esse valor em nosso construtor.
Portanto, dou a você de 5 a 10 segundos para decidir se quer fazer isso sozinho ou não.
Está bem.
Bem-vindo de volta.
Agora vamos dar uma olhada nesse caso.
Portanto, aqui estamos substituindo a implementação do construtor.
Vamos dar uma olhada nesse caso.
Esse é o nosso construtor.
Está bem.
Aqui podemos ver que estamos pegando esse parâmetro e o atribuímos a esse campo de instância.
Isso significa que, se você quiser conectar o construtor, podemos simplesmente modificar esse parâmetro aqui.
Portanto, já fizemos essa abordagem.
Estamos usando o método original, substituindo o parâmetro e, em seguida, chamando esse método mais
uma vez com nossa versão modificada.
Muito bem, vamos fazer isso.
Portanto, aqui mantemos nossa saída de depuração da saída original e, em seguida, precisamos chamar o construtor original.
E isso pode ser feito da seguinte maneira.
Esse ponto nele e, em seguida, precisamos fornecer nosso novo valor.
Vamos fazer desta forma.
Tudo bem.
Acho que isso deve ser suficiente.
Vamos descobrir isso.
Este é o nosso aplicativo.
Este é o nosso script.
Desta vez, também o salvei.
Muito bem, vamos fazer isso.
O aplicativo foi reiniciado e podemos ver a instância de criação de energia do item e assim por diante.
Esse é o nosso primeiro parâmetro.
Agora vamos tentar identificar esse objeto em nossa memória aqui.
E vamos ver.
O que é essa instância?
Valor do campo.
Este aqui.
Este item.
Poder da instância.
Tudo bem.
Certo, vamos escrever o script rapidamente.
Deixe-me escrever isso logo abaixo.
Portanto, agora estamos usando o Char para executar a função e, desta vez, estamos usando o Java para escolher.
Precisamos encontrar todas as instâncias de itens.
Portanto, esse é o item ou essa é a referência da classe.
E, em seguida, temos nossos dois retornos de chamada no clique duplo.
Os colchetes entram na correspondência.
Aqui estamos tendo agora nossa função com essa instância.
Foi encontrada uma instância.
E isso também acessa esse campo de instância.
E vamos escrever dessa forma.
Esse é o poder do item.
Portanto, acessamos essa instância e, em seguida, esse valor de ponto de potência do item.
Tudo bem.
E então estamos fornecendo nosso próprio retorno de chamada completo.
Assim, saberemos que a digitalização foi concluída.
Acho que é assim que foi chamado.
Portanto, termine a digitalização.
Tudo bem.
E agora vamos fazer isso.
Então, levamos esse para a nossa linha de comando aqui e, em seguida, estou fazendo isso em 3 para 1.
Vejamos.
Tudo bem, legal.
Podemos ver.
Encontramos um caso.
Este aqui.
Isso significa que não criamos uma nova instância.
E também podemos ver que o nível de energia dessa instância foi definido com esse valor.
Portanto, agora sabemos que conectamos esse construtor aqui e modificamos esse valor na
geração do construtor.
Muito bem.
Incrível, não é?
Está bem.
Vamos fazer uma rápida recapitulação dos slides e, em seguida, também descobriremos como podemos sobrecarregá-los e construí-los.
Portanto, se tivermos vários, vamos ver como podemos sobrecarregar, enganchar e construí-los.
Muito bem.
Vamos dar uma olhada.
Bem, aqui estamos de volta aos slides na parte superior.
Temos nossa classe de item à esquerda, temos essa imagem incrível e, no botão, temos
o gancho referente ao construtor.
E, desta vez, temos apenas um construtor, portanto, não há sobrecarga, apenas usamos o ponto
nele.
E, em seguida, podemos definir uma nova implementação para essa.
Perfeito.
Se tivermos vários construtores, como neste caso, teremos que simplesmente sobrecarregá-los,
como vimos nos últimos vídeos.
Portanto, aqui temos dois construtores.
Este não tem um parâmetro e este aqui tem um parâmetro inteiro.
Se agora quisermos conectar o que tem o parâmetro inteiro, precisaremos obter nossa referência de classe.
Precisamos aplicar isso nele e no construtor e, em seguida, precisamos sobrecarregá-lo em relação
à quantidade de números e tipos desses parâmetros.
Nesse caso, temos apenas um parâmetro do tipo integer, portanto, estamos livres para saber exatamente
o que queremos enganchar aqui.
Em seguida, podemos acessá-lo e manipulá-lo.
Sim.
Negócios como de costume.
Assim, podemos ver aqui que estamos tendo esse parâmetro e podemos imprimi-lo ou modificá-lo da maneira
que quisermos.
Tudo bem.
Está bem.
No próximo vídeo, daremos uma olhada na manipulação do thread da interface do usuário.
Essa é a última peça que está faltando no momento.
E, depois disso, acho que podemos manipular mais de 95% do nosso código Java em nosso aplicativo Android.
Muito bem.
Está bem.
Portanto, estou ansioso para vê-lo lá.