Metodi Del Java

Share

|

I metodi sono usati mentre i blocchetti di costruzione del vostro programma, effettuanti le mansioni che possono essere denominate diverse volte ed usando lo stesso codice per effettuare ogni volta l'operazione. Le parti di base ma fondamentali della dichiarazione del metodo sono il relativo nome, il relativa tipo di ritorno, firma di parametro e parentesi curve di segmento di codice. Le seguenti linee del codice sono un esempio di una dichiarazione di metodo.

doSomething() vuoto di elettricità statica {// aggiunge 
il codice qui}

Questo metodo è denominato doSomething ed ha un tipo di ritorno di vuoto, che indica semplicemente che il metodo non restituisce un valore. Abbiamo visto già il vuoto di parola chiave, che è il tipo di ritorno della conduttura di metodo. Se il metodo che doSomething fosse aggiunto al vostro codice categoria principale di programma, allora nel metodo principale del codice categoria denominereste il metodo che doSomething impostando il seguente codice:

doSomething();

Noti le necessità doSomething di metodo di essere statico al momento perché la conduttura di metodo, da cui stiamo ammettendo il metodo che doSomething sta andando essere denominata, è inoltre elettricità statica. Il metodo che doSomething non dovrebbe essere statico se generassimo un caso del codice categoria a cui doSomething apparterrebbe.

Se desiderate un metodo che restituisce un valore, dovete specificare il tipo di ritorno del metodo ed allora dovete usare il ritorno di parola chiave nel blocchetto di codice di metodo per specificare il valore restituito.

getFiveDoubled() interno statico {ritorno 10; }

Il seguente metodo restituirà semplicemente il valore di 10 a dovunque sia denominato da. La seguente linea del codice ha potuto essere aggiunta, per esempio, nel vostro metodo principale per assegnare questo valore ad una variabile:

myNumber = getFiveDoubled() interni;

Questa linea del codice assegnerà il valore di 10 al myNumber variabile.

Noti solo perchè il metodo getFiveDoubled ora ha un tipo di ritorno, esso non significa che non può essere invitato il relativi propri.

getFiveDoubled();

Questo metodo essenzialmente non farà niente, ma potete avere un metodo che effettua un'operazione richiesta ed allora restituisce un valore, che desiderate ignorare.

Un metodo che ha un valore di ritorno (non vuoto) deve avere una dichiarazione di ritorno ad ogni punto possibile dell'uscita dal metodo. Il compilatore prenderà se un percorso senza un valore di ritorno è possibile. D'altra parte, se avete un metodo con tipo di ritorno vuoto ed allora desiderate rimuovere presto dal metodo, potete usare il ritorno di parola chiave da sè. Per esempio, prenda il seguente codice:

ritorno vuoto del doSomething() del pubblico 
{if(leaveEarly == allineare); //altrimenti continua con il resto
del codice}

Ciò è simile a come la dichiarazione della rottura è usata per rimuovere da determinati blocchetti di codice, quali i casi dell'interruttore ed i cicli, abbiamo visto più presto. L'esempio che abbiamo visto appena è un esempio molto di base, ma l'uso del ritorno di parola chiave in questo caso può essere molto utile per immediatamente rimuovere dalle serie di ingranaggi complicate di codice in un dato metodo.

Passare Di Parametro

Il metodo precedente, getFiveDoubled, è perché restituirà soltanto un valore, 10 abbastanza superflui e molto inopportuni. Tuttavia, potremmo generare un metodo che prenderà in tutto il numero, lo raddoppiamo ed allora restituiamo il valore raddoppiato. Ciò può essere realizzata usando passare di parametro. Passare di parametro permette che passiate i valori ad un metodo che il metodo può allora maneggiare. Il seguente metodo contiene un parametro, che è raddoppiato ed il nuovo valore è restituito.

numero interno) del doubleNumber(int {numero * = 2; 
numero di ritorno; }

Come potete vedere, il parametro è un numero denominato variabile di tipo interno ed è specificato fra le staffe che seguono il nome del metodo. Per denominare questo metodo, potreste, per esempio, usare il seguente codice:

//doppio 2 del myNumber interno dei uguali 4 = 
doubleNumber(2); //allora raddoppia il relativo numero corrente 
4 di myNumber = di doubleNumber(myNumber) dei uguali 8; //allora
quadruplica il relativo numero corrente per essere uguale il myNumber 
32 = il doubleNumber(doubleNumber(myNumber));

Questa ultima linea del codice denominerà due volte il doubleNumber di metodo, in primo luogo restituendo un valore che è il doppio valore di myNumber, che a sua volta allora è passato poichè un parametro alla seconda chiamata a doubleNumber che finalmente restituisce il valore finale di 32, assegnante lo al myNumber variabile.

Per ripetere che cosa abbiamo accennato più presto, se il valore che passate mentre un parametro è di un tipo di dati primitivo variabile, la variabile in se non è passato al metodo. Una nuova variabile con quel valore è generata nel metodo ed allora è usata. Ciò significa che i cambiamenti fatti a questo valore all'interno del metodo denominato non interesseranno il valore della variabile originale.

Potete anche avere più di un parametro, usando una virgola per separare i parametri successivi. Il seguente esempio semplice, SpidersEyes.java, contiene il metodo si moltiplica, che contiene due parametri che sono entrambi di tipo interno e restituisce il valore dei due parametri moltiplicati insieme. Qui è il codice:

codice categoria pubblico SpidersEyes {valueA interno 
statico pubblico del multiply(int, valueB interno) {valueA di ritorno 
* valueB; } args[ main(String vuoto ] di elettricità statica 
pubblica) {numberOfSpiders interni = 10; eyesPerSpider interno =
8; totalEyes = multiply(numberOfSpiders, eyesPerSpider interni);
System.out.println("Total eyes =" + totalEyes); }}

Ci sono due cose da notare da questo esempio. In primo luogo, abbiamo usato l'elettricità statica di parola chiave per il metodo ci moltiplichiamo. Ciò è perché non ci è caso del codice categoria SpidersEyes attualmente generato, così nell'ordine per la conduttura, che è statica, per potere accedere al metodo si moltiplica, esso deve essere statico anche. La seconda cosa all'avviso è che la conduttura di metodo inoltre prende un parametro, che è un allineamento delle stringhe.

Firme Di Metodo

È possibile avere due metodi che ripartiscono lo stesso nome. Tuttavia, devono avere firme differenti perché al contrario quando desiderate denominare uno dei metodi, il compilatore non hanno senso di differenziare uno dall'altro, poichè il invocation del metodo è basato sul compilatore che riconosce la firma. Avendo metodi dello stesso nome ma con differenti firme è conosciuto come sovraccarico del metodo.

Il nome del metodo e la firma di parametro di quel metodo determinano la firma del metodo. Il tipo di ritorno di metodo non influenza la relativa firma. Quindi non potete avere due metodi con lo stesso nome con due valori di ritorno differenti con la stessa firma di parametro.

Nell'esempio precedente, SpidersEyes.java, abbiamo fatti denominare un metodo per moltiplicarsi, che ha preso due valori di parametro di tipo interni, restituendo il valore dei valori di parametro moltiplicati insieme. Se inoltre includessimo un metodo che ha fatto la stessa cosa ma usassimo i valori di tipo doppio preferibilmente, potremmo generare un altro metodo con lo stesso nome ma con una firma differente di parametro.

multiply(int interno statico pubblico a, b) interna 
{restituisca la a * b; } doppia a multiply(double statica 
pubblica, doppia b) {restituisca la a * b; }

La firma di parametro è determinata dai tipi di dati dei parametri e quindi del numero di parametri anche. Diciamo che ora abbiamo aggiunto il seguente metodo insieme ai due metodi precedenti:

multiply(int lungo statico pubblico a, b) interna {ritorno
(long)(a * b); }

Il programma più non compilerebbe perché questo metodo e l'originale moltiplicano la parte di metodo la stessa firma. Hanno lo stesso nome ed anche gli stessi parametri entrambi—della firma due di parametro di tipo interno. La soluzione più evidente deve cambiare la firma di parametro del metodo posteriore ai parametri dell'introito due di tipo lunghi.

multiply(long lungo statico pubblico a, b) lunga 
{restituisca la a * b; }

Ciò ora funzionerà perché le firme di parametro sono differenti. Se non potete alterare la firma di parametro in un modo ragionevole, non importuni; give giusto i nomi differenti di metodi (per esempio, multiplyInt, multiplyDouble, multiplyLong, ecc.).