Salve, torneremo a questo il più che abbiamo fatto finora e la sezione in cui siamo ora in
una certa misura.
Hai familiarità con i metodi.
Diamo un'occhiata ai metodi in modo più formale.
Sappiamo che un oggetto ha uno stato e il comportamento sul comportamento è definito da metodi o lo stato è
definito da variabili.
I metodi rappresentano una logica che può essere utilizzata da un numero qualsiasi di cose.
È una logica di business del software.
I nostri algoritmi sono codificati in metodi e nulla di utile può essere raggiunto senza metodi che in genere
sono stati ricevuti, non li mette lì, ma qualche elaborazione può finalmente generare un outworker.
Diamo un'occhiata ad una semplice rappresentazione del metodo e della posizione di avere anche un metodo che deve essere invocato
e avremo anche un chiamante che invoca il metodo call è solo un altro pezzo di codice.
E se il metodo richiede alcuni dati di input, il chiamante deve passare i dati di input
al metodo ed eseguire le sue azioni e può restituire alcuni dati al chiamante quindi utilizza ulteriormente i dati restituiti.
Ed ecco il problema della sintassi.
Ha un nome di metodo che è seguito da un elenco opzionale o qualcosa chiamato pedometri che indica l'input
per il metodo e il metodo può come uno o più parametri.
E se non ci sono dei dilettanti vuol dire che il metodo non prende alcun input
sul parametro è semplicemente una variabile e quindi è finito sul nome della variabile dato che un parametro è una variabile.
Può essere un riferimento primitivo o di un oggetto e, come accennato in precedenza,
eseguirà alcune azioni e potrebbe restituire un valore che è l'output del metodo e il valore viene restituito
utilizzando l'istruzione scritta qui.
La parola chiave scritta nella dichiarazione scritta si trova in una parola chiave riservata in Java.
Ora, come i parametri del metodo, il ritorno del valore può anche essere un primer o una fine della loro preferenza.
Può anche essere piacevole o Niekerk al tipo del valore restituito che noi chiamiamo metodi di tipo
restituito è indicato nella dichiarazione del metodo.
Poco prima che il nome del metodo affermi che il tipo di reso nella dichiarazione è obbligatorio e deve anche
apparire subito prima di loro dopo il nome.
Altrimenti riceviamo un errore di compilazione, quindi non è possibile sapere in che modo tra
i metodi il tipo con il mio nome in Java, il nome del metodo sull'elenco dei parametri del metodo insieme viene indicato come
firma del metodo.
Quindi i metodi restituiscono il tipo non fa parte della firma.
A volte Dobler ha erroneamente assunto che il metodo per restituire il tipo sia anche parte della firma.
Quindi ti basterà tenere presente che la firma del metodo include solo il nome del metodo e l'elenco dei
parametri e non il tipo di ritorno.
Ora una volta che il terzo è definito, deve essere richiamato il metodo.
La logica non verrà mai eseguita se non è invocata.
Quindi avresti qualche codice in cui segnarli.
E diamo un'occhiata alla sintassi sul lato dell'invocazione.
La sintassi coinvolge il nome del metodo seguito da tutti i dati di input che devono
essere passati a loro dopo che i dati di input nella parentesi vengono definiti argomenti del metodo o
semplicemente argomenti gli argomenti che Bost deve rispettare singolarmente per i parametri.
Questo è che devono essere di tipo non compatibile.
E nello stesso ordine in Nemeroff gli argomenti devono corrispondere ai parametri del metodo Nemeroff.
Quindi, ad esempio, se il primo parametro nella dichiarazione del metodo è un secondo al secondo è un booleano,
quindi l'invocazione e per il primo argomento la camicia a colori è fantastica e su un tipo di comparatore più piccolo non riesco
a mordere un breve io e un booleano dovrebbe essere passato come secondo argomento.
Altrimenti errore di compilazione del giorno più grande.
Inoltre, se il metodo non accetta alcun input, non abbiamo una parentesi vuota sul lato
dell'invocazione.
Ora qui voglio sottolineare un po 'sulla terminologia.
Puoi vedere che quando parliamo della definizione della materia, faremo riferimento al metodo.
Immettere variabili come parametri.
A volte vengono anche definiti parametri formali.
Tuttavia, quando ci riferiamo all'invocazione del metodo, li chiameremo come argomenti e alcuni si riferiscono
ad esso come parametri attuali.
OK, quindi abbiamo parametri formali e parametri effettivi e poi questo va.
Proviamo a rispettare i termini parametri e argomenti.
Spesso tendiamo a mescolare questi termini, ma il parametro strettamente parlando è il termine giusto quando
parliamo della definizione del metodo.
Mentre l'argomento è il termine giusto quando parliamo dell'invocazione del metodo, infine, se il metodo restituisce
un valore che è tipicamente assegnato ad alcune variabili sulla domanda e sul chiamante per l'uso di esso
in qualche modo.
Tuttavia, nulla impedisce al chiamante di ignorare il valore di ritorno, sebbene ciò sia molto raro.
Inoltre, solo gli argomenti e i parametri devono corrispondere al tipo restituito nella dichiarazione del metodo e
al tipo della variabile sul chiamante e devono anche corrispondere.
Questo è il deve essere fuori sull'urna.
Altrimenti si ottiene un errore di compilazione.
Quindi se li fa nella root e digitano la variabile sui chiamanti e devono essere di tipo nei nostri
dati più piccoli A.
Analogamente, anche il valore restituito dal metodo e il tipo restituito nella dichiarazione
del metodo dovrebbero essere compatibili successivamente.
Diamo un'occhiata ad alcuni dettagli sul tipo di ritorno dei motets.
Esiste un tipo speciale di tipo di ritorno chiamato bianco.
Se il metodo ha Boogle come root e digita allora implica che il metodo non restituisce nulla,
quindi non c'è bisogno di alcuna istruzione scritta.
Potresti voler ricordare che tutti i metodi che abbiamo scritto nelle basi Democritus Hydroid hanno
un tipo diverso e quindi non abbiamo avuto alcuna dichiarazione scritta, tuttavia puoi ancora opzionalmente come la parola scritta
seguita da punto e virgola come i metodi ultima istruzione.
Quindi è solo un modo per dire che il metodo non restituisce nulla, ma in genere non include
tale dichiarazione scritta.
E qui c'è un esempio di tipo scritto grande e scritto è obbligatorio nella dichiarazione del metodo e può essere un tipo
primitivo su un array su un nome di classe o su un'interfaccia di chiamata che vedremo in seguito.
Poche sezioni lungo la linea o può essere giusto che alla fine un metodo deve restituire un valore un tipo frequente è qualcosa
di diverso dal nulla.
Sul wice un errore del compilatore del giorno.
Ora andiamo avanti e testiamo tutto ciò di cui abbiamo appena discusso OK.
Qui siamo nelle basi del mochel noi.
Quindi per questo andiamo avanti e scriviamo un semplice metodo chiamato sum che significa che mi limiterò a calcolare alcuni
nuovi numeri.
Quindi richiede due parametri e calcola quella somma.
Quindi andiamo avanti e scrivilo.
Quindi il tipo di ritorno del metodo sarebbe doppio e il nome del metodo non è stupido.
Il primo è doppio e il nome del parametro è X malato e viene eseguito come doppio e restituirà un valore.
Vorremmo solo dire X meno y.
OK.
Sono uguali anche quanto sia dura la dichiarazione qui.
Ad esempio una doppia Z equivale a esprimere y su record come restituisce Z.
OK, ma possiamo anche avere questo tipo di espressione o possiamo anche tornare.
Lasciaci anche noi.
Ma qui vogliamo calcolare la somma di x e y.
Quindi questo è quello che facciamo, ma la prima cosa che voglio mostrare è che questo doppio ho detto che deve esserlo prima che debba venire prima
di loro un terzo nome.
Quindi se ce l'abbiamo qui.
Quindi abbiamo la parola chiave tra il doppio e alcuni.
Quindi otterremmo un errore di compilazione che vedi qui dice che la dichiarazione di un metodo non valido lo inserisce nel tipo
richiesto.
Quindi dice che abbiamo bisogno di modificare e digitare.
Quindi deve essere prima del nome del motard.
Questo è come dovrebbe essere ora.
Quindi questa è la definizione del metodo.
Ora andiamo avanti e invocarlo.
Quindi definiamo la variabile come double.
Si chiama D.
E guardiamo loro un terzo.
Quindi passiamo 3. Punto 00.
Stampiamo il valore in modo
che il valore che alcuni di essi faccia venga assegnato a questa variabile D e che venga stampato.
Quindi Namir su di esso.
Puoi vederlo solo stampando il valore di.
Quindi l'abbiamo detto.
Quindi questi sono gli argomenti e abbiamo detto che gli argomenti dovrebbero avere una corrispondenza uno a uno di questo.
Quindi vediamo come due argomenti e due doppi qui.
Quindi quel tipo corrisponde anche l'ordine dovrebbe corrispondere sul numero di argomenti dovrebbe anche corrispondere
ai parametri.
Ci dovrebbe essere una corrispondenza uno a uno.
Ora abbiamo anche detto che il pipe dovrebbe essere compatibile, il che significa che possiamo passare qualsiasi punto o doppio valore o raddoppiare
il turno o possiamo anche passare una data o un tipo più piccoli.
Quindi possiamo passare un Halsall difettoso come per il più piccolo del doppio.
Quindi andiamo avanti e compilare la compilazione e leggere su di esso.
Quindi vediamo il valore giusto.
Quindi possiamo farlo anche dopo.
Cambiamo questo per fluttuare qui così
i tipi.
Lo stiamo rendendo imperfetto.
Quindi diciamo tutto questo si cancella lo schermo.
Quindi in questo caso il secondo argomento sta dando un problema perché qui è un tipo incompatibile perché il
secondo argomento che stiamo passando è doppio.
Ma il secondo parametro è difettoso.
OK.
Quindi raddoppiare il rumore di un tipo più grande.
Quindi dobbiamo passare un piano qui.
OK.
Molto più tardi possiamo anche applicare un cast in modo da poter vedere molto.
Quindi possiamo anche fare questo in modo che possiamo mettere un possiamo inserire un costo qui.
Quindi ora entrambi sono flop e abbiamo i parametri di corrispondenza.
Quindi va bene.
Ora qui spiega perché sarebbe difettoso.
Ma il tipo di ritorno è doppio.
Quindi se hai detto che il valore di ritorno deve essere compatibile con questo, così possiamo vedere che qui stiamo ottenendo
dei difetti.
Ma poi qui abbiamo il doppio.
Quindi è comodo.
E quindi non ci sono problemi con questo.
Ora vediamo se questo è difettoso.
Quindi cambiamo questo per far galleggiare e facciamo diventare questo doppio
questo doppio.
Quindi stiamo riassumendo due doppi.
Ma il tipo di ritorno è difettoso.
Quindi questo dovrebbe darti una combinazione del
nostro gioco perché il resto in compatibilità qui deve essere comodo.
Quindi dobbiamo applicare un costo ora qui quando applichiamo il costo.
Quindi, se lo facciamo, il costo verrà applicato solo a X ma non a Y.
OK.
Quindi quello che dobbiamo fare è che possiamo mettere qui la parentesi.
Ora il costo è applicato a chi esprime vite.
Quindi, EX-PRES, perché dovremmo raddoppiare, allora viene applicato un costo e
quindi è meglio farlo compilare bene.
E stampa ancora il valore giusto.
OK, ecco quello che abbiamo.
E qui l'hype è imperfetto su questo e il clamore di questo doppio che storicamente va bene perché è un tipo più piccolo
e può essere assegnato alla grande.
Quindi ci sarà un cast implicito.
OK.
Ecco.
Ma ora cambiamo di nuovo la vecchia forma digitale che dice esprimere perché è per questo che la signora Doppio.
Ora facciamo solo questo difetto.
OK.
Quindi il tipo di ritorno è doppio e sui collari e la variabile è una frode.
OK, quindi un doppio viene assegnato a float ovviamente dovrebbe darci un errore di compilazione.
Ok tipo così incompatibile.
Quindi cosa dovremmo fare.
Quindi dovremmo solo inserire qui
un cast e densificare.
OK, non è così che possiamo applicare un cast in questo modo in modo da poter applicare un costo qui o
possiamo applicare costi qui o possiamo anche applicare un costo nella dichiarazione scritta è un.
Quindi, dopo scriviamo, definiamo un'interruzione della chiamata del metodo e diciamo a b g.
Ok così nella media speriamo di calcolare per la media di questi due numeri.
Quindi, ciò che possiamo fare è definire una variabile card alcune qui ed è un doppio OK.
Direi alcune chiamate per fare uso di questo metodo e passare x.
OK.
Quindi se fossi invocato con qualche input, xey avrà alcuni valori.
Quindi passeremo quei valori ad alcuni.
OK.
Quindi dal metodo medio stiamo invocando lo stesso.
Quindi stiamo realizzando la funzionalità di questo.
E qui abbiamo bisogno di calcolare la somma.
Quindi diciamo solo alcuni divisi per due e qui.
Questo è necessario, quindi fammi solo compilare.
Come puoi vedere inizialmente, stiamo stampando 5 perché ne stavamo lavorando.
E poi quando invochiamo la media, stampa 2. 5.
Quindi è quello che è.
Quindi dal materiale principale stiamo invocando il metodo medio e dalla media stiamo lavorando Gusen.
OK.
Quindi un metodo sta accedendo a un altro argomento su questo e altri metodi stanno accedendo a un altro argomento.
Quindi quello che stiamo vedendo qui è il beneficio di divide et impera.
Quindi, invece di avere esplicito il motivo per cui qui come un metodo separato solo per farlo.
E stiamo riutilizzando.
OK, quindi è la riutilizzabilità del software in azione.
Quindi questo argomento può ora essere utilizzato non solo in media, ma anche altri potrebbero, ad esempio,
utilizzarne alcuni.
E può esserci qualche altro programma che può riutilizzare quel particolare che alcuni possono essere in un
progetto completamente diverso.
OK, così ottieni il vantaggio della riusabilità, non questo particolare metodo è un metodo molto piccolo e
molto piccolo, ma diciamo che se il metodo è davvero enorme se la logica qui è enorme e
se non stiamo facendo uso di metodi, probabilmente finiremmo scrivendo quella e la logica difficile qui in questo metodo e
se abbiamo bisogno di quella logica, scriveremmo quella logica.
E quindi il vantaggio è avere tutta la logica in una questione.
Il vantaggio che otteniamo è che stiamo evitando la duplicazione.
Se quella logica fosse stata duplicata in questo metodo e anche in tutti gli altri metodi dobbiamo fare una
piccola modifica, allora dobbiamo fare quel cambiamento in tutti quei pezzi, ma avendo tutta la logica in un unico
metodo, se il cambiamento ha per essere fatto allora sarebbe incontrato solo in quel particolare metodo.
E possiamo lavorare con quel metodo da tutti i diversi posti.
Quindi questo è il vantaggio di avere metodi.
Quindi, come stai evitando la duplicazione e poi ottieni anche il beneficio della riutilizzabilità in campo,
sembra molto pulito.
Questo è il vantaggio che si ottiene dalla definizione della logica nei metodi.
Ora per la chiave bianca quello che già sappiamo questo.
Quindi abbiamo scritto alcuni metodi nelle nostre demo.
Quindi tutto quanto è ampio.
Quindi non hanno scritto nulla, quindi non abbiamo alcuna dichiarazione scritta come quella che abbiamo in questo caso.
Ora l'ultima cosa che voglio dimostrare è un libro che passa idee.
Quindi diciamo come e la ricerca della terza carta.
Diciamo semplicemente crollin's Boullion e chiamiamolo ricerca.
Per definire un esercito sul chiamato da elencare e diciamo che vogliamo cercare un elemento nella lista e
l'elemento è questo calore.
Quindi questa è solo la definizione del metodo.
Andiamo avanti da qui non importa.
Quindi quello che voglio dimostrare è come possiamo prenotare.
Ora qui dì cerca negli ultimi due e fammi definire la lista qui.
E
quindi questa è la lista.
E vogliamo passarlo su questo compila perfettamente bene.
Ora diciamo se vogliamo un parser qui se vogliamo farlo non funzionerà.
Vedrai che ci dà una combinazione.
Questo perché questo tipo di notazione più semplice che abbiamo per creare array è valida solo nelle dichiarazioni
dichiarazioni.
Ma non possiamo usarlo per invocare un particolare metodo.
OK, quindi stiamo invocando un metodo particolare.
O dobbiamo passare una variabile o dobbiamo usare il secondo in cui dichiariamo le variabili.
Se ricordi che abbiamo avuto questo.
Quindi puoi farlo anche su pass.
E quindi cosa viene creato qui e questo bastardo è un metodo.
Quindi l'unica cosa è che non possiamo fare questa notazione qui.
Pertanto dichiariamo spesso che è valido solo nelle dichiarazioni di dichiarazione.
OK, così non funzionerà se vogliamo passare qui.
Quindi è così.
Fammi solo compilare questo.
Ecco qui.
Quindi compila bene.
Quindi è così.
E così questa notazione funziona solo e dichiarazioni di dichiarazione su di esso non funzioneranno in posizioni moderne o
non funzionerà anche qui.
Puoi anche non poterlo fare anche nelle riassegnazioni non funzionerà.
Kenzer può vedere che ci dà alcuni errori di combinazione in modo che possa essere possibile solo all'interno di una dichiarazione.
Dichiarazioni come questa.
Quindi questo è tutto.
Quindi questa è un'introduzione ai metodi.
Grazie.
Ci vediamo alla prossima lezione.