Ciao.
Tornare.
Facciamo un altro esercizio di pratica.
Ho quindi esteso un po' il nostro file di smiley del giocatore e ora anche di più, perché abbiamo già parlato di numeri
in virgola mobile.
Quindi ne ho aggiunto uno per fare pratica anche su questo.
Passiamo quindi alla macchina virtuale ubuntu e vi ho allegato il file APK da scaricare.
Ho già questo qui e la nostra directory dei download e questo e ho messo questo in applicazioni
e creiamo una nuova pratica di sfida.
Smiley Ok, decompiliamo questo con lo strumento APK.
E poi daremo un'occhiata al codice Marley.
E poi vi mostro il codice Java originale.
E se si guarda a Jade, cosa c'è di diverso?
Credo che ci sia qualcosa di diverso per quanto riguarda l'ottimizzazione del compilatore, ma vediamo questo
alla fine.
Per prima cosa, facciamo il reverse engineering di questa applicazione.
Ok, abbiamo questo qui.
Practice Smiley Ho aperto l'intera directory ancora una volta all'interno del codice di Visual Studio.
Ecco fatto.
Ed ecco la nostra giocatrice, Dot Smiley.
Passiamo a Java e lo prendiamo a calci.
Continuiamo a cliccare su questi fastidiosi pop-up ed eccoci qui.
Ne farò uno screenshot, lo metterò sulla mia tavoletta grafica e lo analizzeremo lì.
Ci vediamo tra qualche secondo.
Va bene.
Ecco, abbiamo questo file in questo momento e potete vedere che è enorme, ma lo facciamo passo dopo passo
e passiamo in rassegna ogni istruzione dopo l'altra.
Includiamo anche ciò che abbiamo imparato nell'ultimo video.
Pertanto, non ci immergiamo in un metodo in questa sede.
Partiamo dall'inizio di questo file.
Esaminando questo file, ricostruiremo il codice sorgente Java dal
codice somalo qui presente.
Cosa abbiamo qui?
Abbiamo la nostra classe public e poi abbiamo questo capital, che significa che abbiamo un riferimento alla classe.
Questo riferimento termina con il punto e virgola qui, il che significa che abbiamo una classe chiamata player.
Scriviamo questo.
Giocatore di classe.
Va bene, allora.
Qui abbiamo la superclasse.
La superclasse è un oggetto itinerante.
Ciò significa che la nostra classe giocatore è una sottoclasse dell'oggetto viaggiante.
Ma qui non stiamo estendendo una certa classe speciale.
Questo significa che siamo già alla fine della definizione della classe.
Credo di aspettare la fine perché potremmo scorrere un po' più in basso.
Va bene.
Quindi abbiamo anche questo e questo e questo è semplicemente il nome dell'azione di riproduzione del file.
Quindi questa era l'intestazione?
Non è così difficile.
Va bene.
Ok, allora lasciate che scelga un colore diverso e che ci faccia strada in questo caso.
Abbiamo il nostro hashtag qui, il che significa che abbiamo un nuovo separatore in questo caso, campi statici.
Ora abbiamo i nostri campi statici per questa classe e abbiamo solo un campo statico, perché alla
fine abbiamo già un nuovo separatore per i campi di istanza.
Ok, vediamo quale campo statico abbiamo.
Abbiamo vite pubbliche statiche.
Questa è l'etichetta.
Quindi il nostro campo statico è lives e lives è di tipo integer.
Possiamo semplicemente scriverlo nello stesso modo.
Quindi lo scriviamo come pubblico.
Statico.
Fine.
E poi ci sono le vite.
Va bene.
Non si vede nessun registro, nessun valore di inizializzazione.
Quindi è sufficiente affidarsi a questo int statico pubblico ama OC.
Diamo poi un'occhiata qui.
Ora abbiamo il nostro campo istanza e due campi istanza.
Uno è il potere e l'altro è la condivisione.
La potenza è di tipo intero ed è di tipo.
Booleano corretto.
Inoltre, aggiungiamo queste informazioni.
Quindi abbiamo un potere finale.
E abbiamo anche bullo e scudo.
Va bene.
Poi arriviamo a questo.
Queste sono tutte le nostre istanze, i campi.
Poi, abbiamo i metodi diretti, cioè i costruttori e i metodi privati.
In questo caso, lo saltiamo perché questo costruttore contiene alcuni riferimenti a oggetti e non ne abbiamo
ancora parlato.
Lo impareremo in alcune sezioni, ma per il momento saltiamo questo punto perché credo che abbiamo ancora molte
cose da fare.
Ok.
Questi sono i nostri metodi privati.
Non abbiamo un metodo privato.
Abbiamo solo questo costruttore, ma lo saltiamo.
Ok.
Allora devo scorrere un po' più in basso.
Facciamo in questo modo che possiamo ancora vedere i nostri campi di istanza e quindi aggiungiamo il nostro codice ora
sotto.
Ok.
Cosa abbiamo qui?
Ora abbiamo i nostri metodi virtuali, il che significa che abbiamo i nostri metodi pubblici.
Il nostro metodo pubblico si chiama power.
Quindi abbiamo un metodo pubblico al potere.
A Paula.
Questo metodo a potenza ha ora tre parametri di nuovo colore.
Qui abbiamo uno, due, tre, tutti del tipo integer.
Ok, ma ora passiamo alle etichette del registro.
In questo caso, quindi, utilizziamo P uno, P due e P tre.
Sappiamo che il nostro P zero è il riferimento per questo oggetto.
Pertanto, i nostri parametri iniziano con p uno.
Inoltre, mantenendo o attenendoci alle etichette del registro, non dobbiamo cercare le cose nel codice.
Pertanto, possiamo eseguire ogni riga dopo l'altra come fa la CPU.
Per quanto riguarda i parametri.
Sì, certo, li abbiamo già qui.
Ma per quanto riguarda le variabili locali o i registri locali, dovremo cercarli se vogliamo indirizzare
immediatamente quelle etichette.
E questo è qualcosa che non vogliamo fare.
Il mio approccio, quando eseguo il reverse engineering intelligente, consiste nell'esaminare ogni riga dopo l'altra
e provare questo.
Va bene.
Abbiamo tre parametri, tutti di tipo intero.
Quindi il nostro primo è in P 1.
Il prossimo è in tpy due.
E poi siamo arrivati a P tre.
Ok.
E possiamo anche vedere questo qui.
Abbiamo il tipo return while del tipo V.
Sai ancora cos'è questa D maiuscola?
Corretto.
È raddoppiato.
Quindi stiamo restituendo un valore doppio.
Va bene.
Abbiamo già la nostra definizione di funzione qui, basata su una riga di smiley.
Non è incredibile?
Lo è assolutamente.
Va bene.
Ora abbiamo questi cinque locali.
E questo è esattamente ciò di cui parlavo nel nostro caso.
In questo momento, prendiamo solo una nevicata, abbiamo cinque registri locali.
Cinque relitti locali, il che significa che abbiamo un registro dallo zero.
Vogliamo che B sia tre e anche V quattro perché iniziamo a contare con v zero.
Non lo facciamo nei tap dei parametri perché p zero è un registro speciale riservato a questa opzione.
Va bene.
Così otteniamo anche questa linea.
Abbiamo anche queste e sì, se vogliamo, possiamo indirizzare queste etichette qui, in modo da poter dire che P uno
è A.
P2 è P e P tre è il fattore B e questo qui è il fattore.
Ok, facciamo in questo modo.
Quindi abbiamo questo, questo e questo.
Ora abbiamo la nostra prima vera istruzione smiley.
Sì, lo definirei così.
Abbiamo quindi lo slash 4000.
Sapete ancora cosa fa questa istruzione?
Quindi questa istruzione avvia il valore w zero in v zero, ma memorizza solo quattro bit di questo valore in v
zero.
Nel nostro caso non ha importanza, perché quattro bit di 01234 sono ancora uguali a zero.
Ma siamo limitati a quattro bit.
In questo caso, non è possibile memorizzare un valore, ad esempio 20.
In questo modo dovremmo regolare questa costola qui, questa forma di slash in qualcosa come slash 16 o rimuovere questa
parte se si vuole sovrascrivere o modificare questa applicazione, questa istruzione qui.
Va bene.
Per ora, sbarazziamoci di questo.
Quindi, ecco qua.
E noi lo scriviamo semplicemente.
Cosa fa l'istruzione?
Lo zero è ora uguale a zero.
Ok.
Il prossimo, li abbiamo qui.
Ah, e qui possiamo vedere il registro.
Questa V0 viene ora indirizzata come variabile e questa variabile si chiama sum ed è di tipo integer.
Ok.
Facciamo questa nota qui.
Quindi ne abbiamo ottenuto un po'.
Mi dispiace.
Lasciatemi pulire velocemente.
Quindi.
Va bene.
Quindi ne abbiamo tagliati alcuni dal tipo integer.
Quindi siamo arrivati ad alcuni e alcuni è uguale a zero in base a questa istruzione prima di questa qui.
Va bene.
E così facendo, non dobbiamo prima cercarlo.
Quindi, ogni istruzione dopo l'altra, procediamo lentamente con il metodo degli smiley.
E questo è l'approccio che mi piace adottare.
Eseguite le istruzioni una dopo l'altra, quindi attenetevi a questi registri e prendete
nota del codice Java sulla destra.
Va bene.
Poi, abbiamo questo contro.
Dovrebbe essercene uno, ma poi c'è questo valore dall'aspetto davvero strano.
Ma abbiamo anche questo indizio qui.
Non sappiamo quindi cosa faccia l'amido di mais.
E questo è un aspetto che dobbiamo verificare per quanto riguarda la prima sezione.
Sappiamo che questo valore viene pensato in B. C. e vogliamo, scusate, che questo valore
venga appreso e che venga inserito in questo registro e che questo valore sia rappresentato da questa strana rappresentazione esadecimale.
Si tratta di un numero in virgola mobile.
E quindi abbiamo il nostro segno, il nostro Manchester e il nostro esponente.
Non ci interessa, perché il valore ce l'abbiamo qui.
Ma cosa fa il Const Dash VI?
Perché è importante cercare le istruzioni quando non si è sicuri di ciò che si sta facendo.
Ciò potrebbe influenzare il risultato di questo registro in seguito.
Diamo quindi un'occhiata.
Pertanto, entriamo nella nostra macchina virtuale Ubuntu e speriamo davvero che abbiate inserito tra i preferiti la pagina dei codici di prelievo.
Quindi vediamo, const dash white mette la costante intera in v x e we x più uno registra l'estensione delle costanti
intere in una costante lunga.
Va bene.
Ciò che fa è.
Ma lasciatemi controllare velocemente una cosa.
Ok.
Dobbiamo fare attenzione.
Vediamo.
Abbiamo questo 16 illuminato.
Nel nostro caso, abbiamo un valore const.
Vediamo.
Abbiamo altri cospiratori nella struttura?
No.
Quindi torniamo indietro e...
Sì.
Ok.
È all'interno della descrizione.
Lo capiamo chiaramente.
Quindi abbiamo const dash wide V due e poi abbiamo la nostra variabile long qui o la nostra variabile double nel
nostro caso.
E qui possiamo vedere che stiamo inserendo 64 bit in X, perché altrimenti avremmo questa dichiarazione Dash 32 nella nostra
istruzione laggiù.
Ok.
Quindi ora sappiamo che stiamo sicuramente inserendo 64 bit nel nostro registro v x in questo caso è V uno.
Ecco fatto.
Va bene.
Permettetemi quindi di fare un po' di chiarezza.
Quindi.
Quindi stiamo inserendo questo nodo a 64 bit, almeno questo valore qui, nel nostro registro.
Scriviamo questo.
Uno è uguale a 2. 3 e non ci interessa questo qui.
E Och, sì, questo è tutto ciò che sappiamo per questa istruzione qui.
E la prossima possiamo ora vederla, ok, abbiamo voluto e vogliamo ora anche una variabile
di nome bias e di tipo double.
Quindi abbiamo un doppio.
Pregiudizio.
E questo è il secondo. 3.
Quindi abbiamo anche questi due.
Poi c'è il nostro ED in costruzione qui.
A.
Il programma prende l'uscita P uno da P due e memorizza il risultato in V tre.
Quindi abbiamo av3 come uguale a P uno più P due.
E qui possiamo vedere che non abbiamo ancora utilizzato la V 3.
Pertanto, per ora manteniamo aperta la questione.
Poi vediamo che il tre non è ancora un riferimento come una variabile, ma non ce ne preoccupiamo, perché passiamo attraverso
questo codice, ogni istruzione dopo l'altra.
Pertanto, se noi tre non siamo mai stati assegnati a una variabile, non ci interessa.
A noi interessa solo il valore o il comando qui.
L'istruzione fa, in questo caso, l'addizione di A più B e la memorizzazione in V tre in questo
registro.
Ed è per questo che mi piace mantenere l'approccio o attenermi ai valori del registro.
Non ci si deve preoccupare di Oh, ora diventa una variabile o no?
Potrebbe essere?
Non potrebbe essere così?
Chi lo sa?
Non ci interessa.
Ok, allora approfondiamo un po' e andiamo avanti a decodificare.
Cosa abbiamo qui.
Ora abbiamo il miglio dash int e questa istruzione è nuova.
È abbastanza chiaro l'effetto di questa istruzione.
Ma in ogni caso, consultiamolo perché così possiamo essere sicuri e non commettere errori stupidi in cui abbiamo
dato per scontato che questa istruzione faccia la cosa seguente e alla fine fa qualcos'altro, qualcosa
di diverso.
Diamo un'occhiata veloce a questo aspetto.
Voglio dire, è super veloce.
Se si ha la possibilità di digitare la password, ci vuole un po' più di tempo, ma è comunque velocissimo.
Quindi stiamo cercando multiply int questo qui moltiplica il valore impostato con w y e inserisce
il risultato nella x oh.
Credo di aver trovato qualcosa.
Sì, questo qui sembra essere un errore.
Sembra che si tratti di un errore di battitura.
Suppongo che questo possa essere B.I.
Tuttavia, questo sito web è straordinario.
Ok, scriviamo questo.
Quindi abbiamo la x uguale, poi abbiamo v y moltiplicato per v set rispetto a una moltiplicazione, credo rispetto
all'operazione aritmetica.
Sì.
Non fa differenza se si moltiplica questo con questo o viceversa.
Quindi, se si scambiano questi parametri, la cosa non ha molta importanza.
Ma sono abbastanza sicuro che dovrebbe essere in questo ordine.
Vediamo cosa abbiamo qui.
Sì.
Avete anche voi questo errore di battitura?
E tu?
Eseguiamo una moltiplicazione da due registri e memorizziamo il risultato in settimane.
Va bene.
Questo è ciò che fa questa istruzione ed è bene che la consultiamo perché ci rendiamo conto che c'è un piccolo
errore di battitura qui.
Quindi torniamo indietro.
Ok.
Moltiplichiamo B tre con p tre e riportiamo il risultato in V tre.
Scriviamo questo.
Quindi farò una piccola nota su dove ci troviamo in questo codice qui noi tre è uguale a v tre moltiplicato
per p tre.
Ora possiamo anche fare un po' di matematica e sostituire la v tre qui con questa.
Ma non facciamolo.
Quindi eseguiamo ogni istruzione dopo l'altra e in seguito eseguiamo e inseriamo i nostri valori nello stesso identico
modo.
Ok?
Quindi non provate a fare operazioni matematiche e a sbarazzarvi di parametri o valori.
Va bene.
Il prossimo, cosa abbiamo?
Abbiamo tagliato la fine del locale a zero.
Questo è interessante.
Non ho mai riconosciuto questa variabile in questo modo, ma sembra che questa sia la
fine di v zero.
A questo punto non utilizziamo più v zero.
Bello.
E per me anche super interessante.
È anche bello vedere che questo registro v tre viene ora riutilizzato.
Ora abbiamo tre allineati ad alcuni super interessanti e vediamo anche questo tipo di intero qui.
Naturalmente abbiamo ancora la nostra somma, ma ora il nostro V 3 sarà referenziato con alcuni elementi.
E almeno a questo punto, voglio dire, non l'ho preparato in questo modo, ma è bello vederlo
qui.
Ma almeno a questo punto, sarei molto confuso se ci attenessimo a questi nomi di variabili.
Per quanto riguarda i registri, non ci interessa.
Andiamo avanti con il nostro codice e non ci interessa se questo B tre non è alcuni o B zero è alcuni.
A noi interessano solo i valori che questo registro contiene e quindi mi piace molto questo approccio per
quanto riguarda l'attenersi ancora di più a questi registri.
Ok, allora andiamo avanti e vediamo cosa abbiamo.
Poi aggiungiamo l'int litt 8.
Quindi sappiamo che è a otto bit.
E aggiungiamo i tre.
Bello.
Sommiamo tre con meno uno e ricominciamo il risultato con tre.
Quindi non stiamo aggiungendo valori, ma sottraendo valori.
Non sono sicuro del motivo per cui il compilatore abbia scelto questa istruzione, perché c'è anche una sottrazione, e credo che sia il
caso di dare un'occhiata.
Sì, è già sopra questa istruzione qui.
SAP calcola l'insieme revi meno V.
Quindi questo potrebbe riguardare l'ottimizzazione del compilatore.
Il compilatore o il programma potrebbero essere più veloci se aggiungessero meno uno invece di usare l'istruzione sub.
Super ridicolo.
Ma va bene, questo è ciò che fa il compilatore.
È divertente vederla in questo modo.
Bene, allora scriviamo questo.
B tre è ora b tre.
Possiamo scriverlo come più meno uno.
E ora abbiamo la nostra operazione matematica di fantasia.
Ma per me questo è un po' confuso.
Quindi, facciamo questo in un modo diverso.
Scriviamo le cose come stanno.
Va bene.
Ok.
Poi, abbiamo una nuova istruzione.
Cosa potrebbe essere?
Nessuno lo sa.
Credo di sì.
Abbiamo il div dash int p uno, v tre, p due.
Quindi, come vedete, con questi registri ora sta diventando un po', diciamo, un po' più grande.
Sì, complicato o confuso.
Ma se inseriamo i nostri valori in seguito e procediamo passo dopo passo, vedrete che non è poi
così difficile eseguire questo codice sul nostro foglio.
Quindi vediamo prima questa istruzione e poi questa int, per verificare che l'ordine sia corretto.
Sì.
Risultato.
Va bene.
Quindi il dispositivo v vi con V impostato e mette il risultato in settimane.
Hmm.
Vediamo il pollice.
Abbiamo il p uno.
Siamo quindi a questa istruzione in questo momento.
P uno è uguale a v tre diviso p due.
Eppure possiamo provare a inserire le nostre etichette qui.
Quindi vediamo.
p1i devo scorrere verso l'alto.
P uno è a a è uguale a qualche perché qualche da questo punto è ora e registro v tre.
Possiamo anche scriverlo qui.
La somma è uguale alla somma meno uno.
Ok.
A questo punto siamo stati divisi da P a P due è P.
Ok.
Sì.
Va bene.
Poi, abbiamo questa istruzione x ordini in XO.
Controlliamo questo dato.
Eccellente.
INT E qui vediamo che c'è un problema da affrontare.
Non stiamo cercando questo.
Stiamo cercando questo.
Sbarazziamoci di questo.
Calcola che compriamo ciò che abbiamo impostato e mette il risultato in settimane.
Ok.
Quindi abbiamo zero.
Zero è uguale a 33x o con p uno.
In questo caso.
Noi zero è ora.
E questo è cresciuto un po'.
È così interessante.
Possiamo vedere che in questo momento stiamo usando lo zero come registro, ma a questo punto siamo
passati dallo zero al tre per il registro o l'etichetta.
Questo significa che ora abbiamo un nuovo registro libero.
Questo qui.
Questo è stato riassegnato e riutilizzato.
Si tratta quindi di un registro completamente nuovo.
Pertanto, non possiamo creare un'etichetta Yeah per questo qui.
Ancora una volta, questo è il motivo per cui mi piace attenermi ai registri e non cercare sempre di aggiustare i nomi delle variabili,
perché in questo caso non abbiamo un nome per questa variabile al momento.
Sappiamo che questo è un po' e notiamo che questo è un sì?
Ok.
Sappiamo che questo è some e questo è export con a, ma non abbiamo un'etichetta per questo
qui.
Quindi dobbiamo andare avanti nel codice.
Quindi la CPU esegue semplicemente questo comando, qualche esportazione con a e avvia il risultato in B zero.
A proposito, se non avete o non avete familiarità con l'istruzione XOR, ho allegato un'apposita
sezione all'interno del cheat sheet di questo corso.
In questa sezione descrivo alcune operazioni XOR, cosa fa lo XOR e perché è davvero utile capire lo XOR,
perché l'esportazione viene utilizzata molto per le funzioni crittografiche e per le strane funzionalità crittografiche
che vengono scritte dallo sviluppatore stesso e anche per l'assemblaggio, ad esempio, per cancellare
i registri e cose del genere.
L'istruzione in sé non è molto complicata, ma è molto utile se si capiscono o si conoscono
i trucchi che si possono fare con X o per recuperare alcune chiavi crittografiche e cose del genere.
Pertanto, date un'occhiata alle diapositive e forse creerò anche una sezione bonus dedicata allo
XOR.
Va bene.
Si prega di consultare il materiale.
Anche nel video bonus.
Sono sì, sono abbastanza sicuro di aver creato questo.
E se avete domande in ogni caso, allora sì, sentitevi liberi di scrivermi un messaggio al riguardo.
Va bene.
Ok.
Sì, interessante.
Quindi ora la fine locale B è tre.
Quindi la nostra variabile somma di tipo intero è ora finita nel registro con tre.
Non c'è più nulla che trattenga la somma.
Ecco cosa fanno queste istruzioni.
E qui possiamo vedere che il riavvio di un basso può essere a somma zero dal tipo intero.
Quindi vediamo che stiamo riutilizzando il registro v0 come variabile somma.
Questo significa che l'azzeramento diventa.
Alcuni sono tornati indietro.
Va bene.
E a questo punto sappiamo che anche questo è un po' diverso.
Quindi, in questo caso, si tratta di una sorta di segnaposto.
Quindi abbiamo un segnaposto per alcuni.
E dopo ci siamo riciclati in tre.
Quindi questo registro viene riciclato e poi creiamo la nostra somma qui per V zero.
Ok.
Se ci si attiene a queste etichette, le cose si complicano un po'.
Ripuliamo il tutto e scriviamolo come ci dicono le istruzioni.
Quindi abbiamo questo qui.
Questa era la parte.
E poi abbiamo il ritorno di V0 locale ad alcuni.
Questa è questa parte, ma non si tratta di istruzioni vere e proprie.
Quindi non facciamo progressi all'interno del nostro codice in questo momento fino a quando.
Quindi abbiamo anche questo.
Sì.
Fino a quando non entreremo in questo, perché ora possiamo vedere il doppio v3v0.
Controlliamo quindi quale int raddoppiare.
Fallo per raddoppiare.
Congrega l'intero e b y nel doppio in b, x e b x più uno e questo b x più uno, a proposito.
Ciò significa che se il valore non entra in un registro, ne usiamo due.
Quindi diciamo che stiamo usando v tre, questo sarà v tre, questo v x quindi v tre è v x o y è meglio.
Supponiamo che un'altra v x sia b tre e quindi stiamo usando anche v x più uno, il che significa che stiamo usando
anche V per il registro.
E credo che tu possa trovare questo.
Vediamo.
Nella descrizione.
Sì.
Già.
Qui si può vedere questo.
Più uno significa che stiamo usando il registro per memorizzare questo valore.
Ad esempio, se abbiamo un valore Yeah più grande, che va in un registro più piccolo, allora dividiamo questo
valore in due registri, ad esempio.
Ok, allora cosa abbiamo qui?
La nostra istruzione dice che stiamo convertendo il tre in V zero.
Mi dispiace.
Devo controllare ancora una volta.
Converte il numero intero in v.
Quindi questo è il numero intero due e doppio.
Ok.
Quindi questo è l'intero.
E questo è il doppio dopo.
Sì.
Questo ha senso.
Ok.
E proviamo a scriverlo.
È un po' difficile.
Vediamo.
Quindi questo è in pollici e questo è doppio.
Quindi abbiamo noi tre.
Doppio zero.
Ok.
Questo significa che anche B 3 è di tipo double.
Ma non scriviamolo qui.
Scriviamo questo.
Cosa c'è qui?
Ok.
Così dovrebbe essere.
Sì, questo sarebbe appropriato.
Va bene.
E poi c'è il ritorno di V tre.
Vediamo se trovate anche questa istruzione qui.
Ritorno del cruscotto bianco.
Ritorno con risultato doppio o lungo e così via.
Ok, quindi stiamo tornando con zero e abbiamo vinto nel registro e in questi registri e questo è solo il ritorno
di un valore double o long.
Quindi stiamo riportando qui la B 3.
Giusto.
E questo è il nostro codice.
Se tornate su questo argomento.
Questo è il metodo al potere.
Questo è ciò che fa un potere.
E ora possiamo semplicemente inserire alcuni valori qui.
E poi possiamo esaminare questo codice qui e verificare qual è il risultato a questo punto?
E vediamo.
Forse lo facciamo.
Sì, facciamo questo o facciamo questo per la sezione successiva.
E poi vi mostro anche il codice Java.
Eseguiamo questo metodo con i valori che inseriamo qui.
Poi diamo un'occhiata al codice Java, ma il codice Java mette come risultato questa funzione e anche ciò
che abbiamo ottenuto da questa funzione.
E sì, prendiamo già alcuni valori che potete iniziare a mettere in pratica se volete.
Valori S.
Vediamo di prendere per un.
Uno, tre, tre, sette.
Sì.
Questi sono i valori che inseriamo e che utilizziamo per chiamare questo metodo.
Uno, tre, tre, uno, tre, tre, sette.
Sì.
Lasciate che mi liberi di questo ping.
Quindi scriviamo questo ancora una volta.
Uno, tre, tre, sette.
Spero che funzioni in questo modo perché non ho controllato il codice per quanto riguarda
overflow o cose del genere, ma non sono sicuro di cosa stiamo facendo con B, quindi B è p due.
Controlliamo rapidamente questo codice.
Abbiamo qui due persone.
Ci stiamo dividendo.
Pertanto, se B fosse pari a zero, ciò sarebbe negativo perché non possiamo dividere per zero.
Sì, ma il resto sembra a posto.
OC Sì, quindi sembra esserci un bell'esercizio e prima di farlo, facciamo un passo indietro, diamo un'occhiata
all'immagine e vediamo cosa abbiamo fatto.
Abbiamo codice Java invertito e più complesso basato su Smiley.
Abbiamo quindi ricostruito il codice Java a partire da questo.
E questo è piuttosto sorprendente, secondo me, perché abbiamo già iniziato a imparare lo smiley e possiamo
già risolvere nomi di metodi complessi o compiti di metodi qui.
Quindi, a mio parere, sono super impressionato dal punto in cui ci troviamo in questo momento e spero che anche voi la pensiate
così.
Altrimenti, non essere molto.
In seguito aumenteremo il ritmo e faremo cose ancora più fantasiose e avanzate.
Ma per ora, sì, godiamoci questo momento e inseriamo questi valori, qualche tipo di esercizio fisico.
E dopo affrontiamo questo percorso insieme.
Divertitevi e ci vediamo nel prossimo video.