Metody w Javie

Jest jedna interesująca zasada, o której wielu słyszało. Nazywa się to „Dziel i zwyciężaj”. Zasada ta stosowana jest w wielu dziedzinach życia ludzkiego, na przykład w polityce. Oznacza podział dużej liczby heterogenicznych części państwa, podżegając i wykorzystując wrogość między tymi częściami. Innymi słowy: stworzyć konflikt pomiędzy tymi, którzy potencjalnie stanowią zagrożenie dla władzy. Ale jesteśmy programistami, więc interesuje nas tylko techniczna interpretacja tej zasady. Brzmi to tak: „Zasada „Dziel i zwyciężaj” polega na dzieleniu dużego problemu na mniejsze, aż staną się elementarne. Następnie musisz je rozwiązać sekwencyjnie i połączyć wszystko w jeden cały system. Ten program powinien rozwiązać zadany problem”. Oznacza to, że po prostu dzielisz duży problem na mniejsze, które nie stanowią dla ciebie problemu do rozwiązania. A potem zbierasz rozwiązanie w jeden duży. Aby postępować zgodnie z tą prostą i użyteczną zasadą, programowanie w języku Java wykorzystuje metody. Na przykład tworzymy boksera-robota. Ważne jest dla nas, aby dobrze się poruszał, wyprowadzał celne ciosy, a także obserwował wroga w poszukiwaniu słabych punktów. Zapisanie tego wszystkiego w jednej głównej metodzie byłoby niewygodne , prawda? Jeśli opiszemy wszystko jedną metodą, będzie to mniej więcej tak:

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

Co się stanie, jeśli będziemy musieli wykonać krok do przodu lub kopnąć w innym miejscu programu? Opisać ponownie wszystkie działania? Nie pasuje. Zbyt wiele powtarzających się linii, w których łatwo się zgubić. Musimy umieścić opis szczegółów akcji w osobnym module, który wykona krok robota. I możemy wywołać metodę w jednym wierszu. Coś takiego:

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

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

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

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

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

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

Teraz rozdzieliliśmy funkcjonalność robota, a także zwartą i przejrzystą metodę main() . Pozostałe metody również można podzielić na dowolną funkcjonalność, np. deceptiveAttackingStrike można podzielić na metody deceptiveMovement , Leg Movement , Attack . A oni z kolei przydzielani są do prostszych zadań, aby ostatecznie otrzymać zestaw elementarnych. OK, teraz napiszmy to wszystko pięknie w formie, którą zaakceptuje Java.

public static void stepForward() {
  	    // Многострочный kod, описывающий
  	    // действия робота для выполнения шага
  	    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() {
    	// Метод проверяет, атакует ли враг. zwroty логическое oznaczający.
    	return true;
}

Rozumiem, że ten kod może być teraz dla Ciebie trochę niejasny, szczególnie niektóre słowa takie jak void , return i tak dalej. Nie spiesz się z rzucaniem pomidorów, teraz wszystko wyjaśnię. Ogólna idea paradygmatu „Dziel i rządź” powinna być dla Ciebie jasna. Pomogą nam w tym metody. Ogólna struktura deklaracji metod jest następująca:

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

Modyfikator dostępu

Modyfikator dostępu składa się z kilku słów kluczowych: public , private , package . Te słowa wskazują zakres metody. Wyjaśnię to prosto: tym słowem wydaje się, że dzielisz się z innymi smakowitym poczęstunkiem. Pyszne to Twoja metoda. Jeśli jest private , nie udostępniasz tej metody innym klasom. Jeśli pakiet , udostępniasz tylko klasom znajdującym się w pakiecie (klasy są zebrane w określone pakiety, dowiesz się o tym później). Cóż, publiczność pokazuje, że jesteś samą dobrocią i dzielisz się pysznym poczęstunkiem (metodą) z całym programem. Coś takiego. Po kilku poziomach znacznie lepiej zrozumiesz rolę tych słów.

Wartość zwracana

Spójrz na powyższy przykład: wszystkie metody są oznaczone słowem kluczowym void , z wyjątkiem jednego - isEnemyAttacked , które zwraca wartość logiczną . Jeśli metoda jest oznaczona jako void , może nic nie zwrócić. Ta metoda po prostu wykonuje zestaw działań i to wszystko. Teraz zwróć uwagę na główną metodę . Metody, które zwracają void, nazywane są właśnie w ten sposób w treści metody. Jednak metoda isEnemyAttacked jest wywoływana w nawiasach instrukcji if . Dzięki temu, że zwraca wartość logiczną, otrzymujemy możliwość nie użycia zmiennej pośredniej, a wstawienie jej bezpośrednio. Zwrócenie wartości następuje przy użyciu słowa kluczowego return . Jeśli metoda zwraca typ int , możemy wywołać metodę z dowolnego wyrażenia:

public static int getNumber() {
 	    return 5;
}

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

Wniosek: Metoda getNumber zwraca wartość int , więc możemy ją wywołać z wyrażenia. Ponadto metoda może zwrócić dowolny typ, w tym te, które sam utworzyłeś. Jeśli określiłeś typ zwracany dla metody, musisz coś zwrócić. Nie możesz napisać tego w ten sposób:

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

Kompilator będzie cię skarcił, że gdy spełniony zostanie pierwszy warunek, coś zwrócisz, ale gdy spełniony zostanie drugi warunek, nie.

Przekazywanie parametrów

Do metody można przekazać parametry, które są wykorzystywane podczas jej działania. Najbardziej prymitywnym przykładem jest sumowanie dwóch liczb. Ale nie jesteśmy prymitywni, prawda? Weźmy inny przykład, dość stereotypowy. Powiedzmy, że mamy metodę szef kuchni() - kucharz. Składniki zupy możemy przekazać do tej metody w bloku parametrów, w efekcie metoda ta zwróci nam zupę. Lubię to:

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

}

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

(Powiedzmy, że mamy wcześniej utworzoną klasę Zupa ) W metodzie głównej tworzymy szereg składników, a następnie „dajemy je szefowi kuchni” (przekazujemy to metodzie szefa kuchni ). „Kucharz gotuje zupę”, a następnie zwraca ją nam jako obiekt klasy Zupa . Wszystko jest bardzo proste. Do metody można przekazywać dowolne parametry, typy pierwotne, obiekty, tablice itd.

Przekazywanie parametrów przez referencję i wartość

W języku programowania Java dowolne parametry są przekazywane do metody na podstawie ich wartości. Jednak mechanizm ten jest inny w przypadku typów pierwotnych i obiektów. Jeśli przekażesz dowolny typ pierwotny do metody i zmienisz go, nie zmieni się on w metodzie głównej. Po prostu przekazałeś kopię wartości, a oryginalna zmienna została zachowana. Najprostszy przykład:

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;
	}

Wniosek: Natomiast w przypadku obiektów zmiany dotyczą obiektu pierwotnego:

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;
	}
}

Wniosek: Mamy klasę WiseMan , która ma właściwość iq . Oraz dwie metody kontrolujące wartość tego pola. W metodzie głównej tworzymy obiekt mądryMan , ustawiamy wartość iq na 300 . Następnie do metody ChangeObject przekazujemy naszego mędrca z iq 300. Ale w tej metodzie robi się głupi. Ustawiamy wartość iq na 100. Następnie w metodzie głównej wypisujemy obiekt. Widać, że w metodzie ChangeObject manipulujemy kolejnym mędrcem w zmiennej m . Modyfikujemy jednak nasz oryginalny obiekt. Faktem jest, że obiekt mądryMan w metodzie main i obiekt m w metodzie ChangeObject to ten sam mądry człowiek, a referencja do obiektu jest kopiowana do metody jako parametr. Należy o tym pamiętać podczas edycji obiektu w poszczególnych metodach.

Na koniec kilka słów o modyfikatorze statycznym

Generalnie kilka słów tutaj nie wystarczy, ale spróbuję. Zwykłe metody nieoznaczone tym modyfikatorem należą do obiektu klasy. Metody statyczne należą do samej klasy . Zwykłe metody można stosować na pojedynczych obiektach. Spójrz na klasę WiseMan z powyższego przykładu. Każdy mędrzec będzie miał swoje własne metody getIq i setIq , ponieważ poziom IQ każdego jest inny. Jeśli dodamy do tej klasy metodę statyczną generateAWisePhrase , to będziemy mogli wywołać taką metodę bez obiektu:

WiseMan.generateAWisePhrase();

W sumie na razie te informacje wystarczą, bo o statyce można napisać kilka wykładów . Pisząc metodę utrzymującą porządek w kodzie, przestrzegaj kilku zasad:

• Nadaj swoim metodom znaczące nazwy, aby było jasne, co robią.
• Staraj się nie pisać bardzo długich metod. Optymalna długość to 8-15 linii.
• Liczba parametrów metody nie powinna przekraczać 4-5.
• Jeśli dwa razy masz w swoim kodzie podobną funkcjonalność, zastanów się: może warto ją uogólnić i umieścić w osobnej metodzie?

Techniki te pomogą Ci poprawić wydajność programu i, co najważniejsze, sprawią, że Twój kod będzie bardziej czytelny.