Metodi in Java

C'è un principio interessante di cui molti hanno sentito parlare. Si intitola "Dividi e conquista". Questo principio è utilizzato in molti ambiti della vita umana, ad esempio in politica. Denota la divisione di un gran numero di parti eterogenee nello stato, incitando e usando l'ostilità tra queste parti. In altre parole: creare conflitto tra coloro che potenzialmente rappresentano una minaccia per il potere. Ma noi siamo programmatori, quindi a noi interessa solo l'interpretazione tecnica di questo principio. E va così: “Il principio del “Divide et impera” è quello di scomporre un grande problema in problemi più piccoli fino a farli diventare elementari. Quindi è necessario risolverli in sequenza e combinare tutto in un unico sistema. Questo programma dovrebbe risolvere il problema dato”. Cioè, dividi semplicemente un problema grande in problemi più piccoli, che non sono un problema da risolvere. E poi raccogli la soluzione in una grande soluzione. Per seguire questo principio semplice e utile, la programmazione Java utilizza metodi. Ad esempio, stiamo creando un pugile robot. Per noi è importante che si muova bene, sferri colpi precisi e osservi anche il nemico alla ricerca di punti deboli. Sarebbe imbarazzante scrivere tutto questo in un unico metodo principale , non è vero? Se descriviamo tutto in un unico metodo, sarà qualcosa del genere:

метод main() {
// Описание действий шага вперед
подача напряжения в отдельные модули;
поднятие ноги;
перевод в другую точку;
поставить ногу;
перенести вес на другую ногу;
если (противникАтакует()) {
        	// Описание действий уклонения робота.
        	...
} еслиНет {
        	// Описание действий обманного атакующего удара.
        	...
}
// Описание действий шага назад
...
}

Cosa succede se dobbiamo utilizzare un passo avanti o un calcio altrove nel programma? Descrivere nuovamente tutte le azioni? Non adatto. Ci sono troppe righe ripetute in cui è facile perdersi. Dobbiamo inserire la descrizione dei dettagli dell'azione in un modulo separato, che eseguirà il passaggio del robot. E possiamo chiamare il metodo in una riga. Qualcosa come questo:

метод шагВперед() {
// Описание действий шага вперед
  	подача напряжения в отдельные модули;
  	поднятие ноги;
  	перевод в другую точку;
  	поставить ногу;
  	перенести вес на другую ногу;
}

метод уклонение() {
  	// Действия для уклонения
  	...
}

метод обманныйАтакующийУдар() {
  	// Действия для удара
  	...
}

метод шагНазад() {
  	// Действия для шага назад
  	...
}

метод противникАтакует() {
	// Робот проверяет атакует ли противник
}

метод main() {
	шагВперед();
	если (противникАтакует()) {
        	уклонение();
	} еслиНет {
  	  обманныйАтакующийУдар();
	}
	шагНазад();
}

Ora abbiamo funzionalità separate del robot, nonché un metodo main() compatto e chiaro . I restanti metodi possono anche essere suddivisi in qualsiasi funzionalità, ad esempio, l'attacco ingannevole può essere suddiviso in metodi inganno Movimento , Movimento delle gambe , attacco . E a loro volta vengono assegnati compiti più semplici per ottenere alla fine una serie di compiti elementari. Ok, ora scriviamo tutto magnificamente in una forma che Java accetterà.

public static void stepForward() {
  	    // Многострочный code, описывающий
  	    // действия робота для выполнения шага
  	    System.out.println("The robot takes a step forward");
}

public static void evasion() {
  	    // Действия для уклонения
  	    System.out.println("Robot shy of impact");
}

public static void deceptiveAttackBlow() {
  	    // Действия для удара
  	    System.out.println("The robot performs a deceptive strike");
}

public static void stepBack() {
  	    // Действия для шага назад
  	    System.out.println("The robot takes a step backwards");
}

public static void main(String[] args) {
    	stepForward();
    	if (isEnemyAttacked()) {
        		evasion();
    	} else {
  	    	deceptiveAttackBlow();
    	}
    	stepBack();
}

public static boolean isEnemyAttacked() {
    	// Метод проверяет, атакует ли враг. returns логическое meaning.
    	return true;
}

Capisco che questo codice potrebbe risultarti poco chiaro adesso, specialmente alcune parole come void , return e così via. Non abbiate fretta di lanciare i pomodori, vi spiego tutto adesso. L’idea generale del paradigma “Divide et impera” dovrebbe esserti chiara. I metodi ci aiuteranno in questo. La struttura generale delle dichiarazioni di metodo è la seguente:

модификатор_доступа возвращаемое_meaning Name_метода(принимаемые_параметры) {
   	//Тело метода
}

Modificatore di accesso

Il modificatore di accesso è costituito da diverse parole chiave: public , private , package . Queste parole indicano la portata del metodo. Te lo spiego semplicemente: con questa parola ti sembra di condividere con gli altri un gustoso dolcetto. Yummy è il tuo metodo. Se è privato , non condividi il metodo con altre classi. Se package , condividi solo con le classi all'interno del pacchetto (le classi vengono raccolte in pacchetti specifici, lo imparerai più tardi). Bene, il pubblico dimostra che sei la gentilezza stessa e condividi una deliziosa sorpresa (metodo) con l'intero programma. Qualcosa come questo. Dopo alcuni livelli capirai molto meglio il ruolo di queste parole.

Valore di ritorno

Guarda l'esempio sopra: tutti i metodi sono contrassegnati con la parola chiave void , tranne uno - isEnemyAttacked , che restituisce un valore booleano . Se un metodo è contrassegnato come void , potrebbe non restituire nulla. Questo metodo esegue semplicemente una serie di azioni e il gioco è fatto. Ora presta attenzione al metodo principale . Quei metodi che restituiscono void vengono chiamati proprio così, nel corpo del metodo. Ma il metodo isEnemyAttacked viene chiamato tra parentesi dell'istruzione if . Dato che restituisce un valore booleano, abbiamo la possibilità di non utilizzare una variabile intermedia, ma di inserirla direttamente. La restituzione di un valore avviene utilizzando la parola chiave return . Se un metodo restituisce tipo int , possiamo chiamare il metodo da qualsiasi espressione:

public static int getNumber() {
 	    return 5;
}

public static void main(String[] args) {
    	int result = 5 + 6 + getNumber();
    	System.out.println(result);
}

Conclusione: Il metodo getNumber restituisce un valore int , quindi possiamo chiamarlo da un'espressione. Inoltre, il metodo può restituire qualsiasi tipo, compresi quelli creati dall'utente. Se hai specificato un tipo restituito per un metodo, devi restituire qualcosa. Non puoi scriverlo così:

public static int findMaxNumber(int a, int b) {
 	if(a>b) {
 	    return a;
 	}
}

Il compilatore ti rimprovererà che quando viene soddisfatta la prima condizione, restituisci qualcosa, ma quando viene soddisfatta la seconda condizione, no.

Passaggio dei parametri

È possibile passare i parametri al metodo che vengono utilizzati durante il suo funzionamento. L'esempio più primitivo è la somma di due numeri. Ma non siamo primitivi, giusto? Facciamo un altro esempio, abbastanza stereotipato. Diciamo che abbiamo un metodo chef() - cook. Possiamo passare gli ingredienti della zuppa a questo metodo nel blocco parametri e, di conseguenza, questo metodo ci restituisce la zuppa. Come questo:

public static void main(String[] args) {
    	String[] ingredients;
    	// Инициализация массива ингредиентов
    	Soup soup = chef(ingredients);

}

public static Soup chef(String[] ingredients) {
    	Soup soup = new Soup();
    	// Процесс варки супа
    	return soup;
}

(Diciamo che abbiamo una classe Soup pre-creata ) Nel metodo principale, creiamo una serie di ingredienti e poi "lo diamo allo chef" (lo passiamo al metodo dello chef ). “Il cuoco prepara la zuppa” e poi ce la restituisce come oggetto della classe Zuppa . Tutto è molto semplice. È possibile passare al metodo qualsiasi parametro, tipo primitivo, oggetto, array e così via.

Passaggio di parametri per riferimento e per valore

Nel linguaggio di programmazione Java, tutti i parametri vengono passati a un metodo in base al loro valore. Tuttavia, questo meccanismo è diverso per i tipi primitivi e per gli oggetti. Se passi un tipo primitivo in un metodo e lo modifichi, non cambierà nel metodo principale. Hai semplicemente passato una copia del valore e la variabile originale è stata preservata. L'esempio più semplice:

public static void main(String[] args) {
    	int x = 1;
    	System.out.println(x);
    	getNumber(x);
    	System.out.println(x);

	}

	public static void getNumber(int i) {
    	i = i + 100;
	}

Conclusione: Tuttavia, nel caso degli oggetti, le modifiche influiscono sull'oggetto originale:

public class Program
{
	public static void main(String[] args) {
    	WiseMan wiseMan = new WiseMan();
    	wiseMan.setIq(300);
    	System.out.println(wiseMan);
    	changeObject(wiseMan);
    	System.out.println(wiseMan);

	}

	public static void changeObject(WiseMan m) {
    	m.setIq(100);
	}
}

public class WiseMan {
	int iq;

	public void setIq(int iq) {
    	this.iq = iq;
	}

	public int getIq() {
    	return iq;
	}

	public String toString() {
    	return "Our wise man has an IQ "+iq;
	}
}

Conclusione: Abbiamo una classe WiseMan che ha una proprietà iq . E due metodi che controllano il valore di questo campo. Nel metodo principale creiamo un oggetto WiseMan , impostiamo il valore iq su 300 . Quindi passiamo il nostro saggio con iq 300 al metodo changeObject , ma in questo metodo diventa stupido. Impostiamo il valore di iq su 100. Quindi nel metodo main stampiamo l'oggetto. Puoi vedere che nel metodo changeObject stiamo manipolando un altro saggio nella variabile m . Tuttavia, stiamo modificando il nostro oggetto originale. Il fatto è che l' oggetto WiseMan nel metodo main e l' oggetto m nel metodo changeObject sono lo stesso WiseMan e un riferimento all'oggetto viene copiato nel metodo come parametro. Tienilo a mente quando modifichi un oggetto nei singoli metodi.

Infine, qualche parola sul modificatore statico

In generale, alcune parole non basteranno qui, ma ci proverò. I metodi regolari non contrassegnati con questo modificatore appartengono all'oggetto classe. E i metodi statici appartengono alla classe stessa. I metodi regolari possono essere utilizzati su singoli oggetti. Guarda la classe WiseMan dell'esempio sopra. Ogni saggio avrà i propri metodi getIq e setIq , perché il livello di QI di ognuno è diverso. Se aggiungiamo un metodo statico generateAWisePhrase a questa classe , possiamo chiamare tale metodo senza un oggetto:

WiseMan.generateAWisePhrase();

In generale, queste informazioni per ora sono sufficienti, perché si possono scrivere diverse lezioni sull'elettricità statica . Segui alcune regole quando scrivi un metodo per mantenere l'ordine nel tuo codice:

• Dai ai tuoi metodi nomi significativi in ​​modo che sia chiaro cosa fanno.
• Cerca di non scrivere metodi molto lunghi. La lunghezza ottimale è di 8-15 righe.
• Il numero di parametri del metodo non deve superare 4-5.
• Se hai funzionalità simili due volte nel tuo codice, pensa: forse vale la pena generalizzarlo e inserirlo in un metodo separato?

Queste tecniche ti aiuteranno a migliorare le prestazioni del tuo programma e, soprattutto, a rendere il tuo codice più leggibile.