Methoden in Java

Es gibt ein interessantes Prinzip, von dem viele gehört haben. Es heißt „Teile und herrsche“. Dieses Prinzip wird in vielen Bereichen des menschlichen Lebens angewendet, beispielsweise in der Politik. Es bezeichnet die Spaltung einer großen Zahl heterogener Teile des Staates und die Anstiftung und Nutzung von Feindseligkeiten zwischen diesen Teilen. Mit anderen Worten: Konflikte zwischen denjenigen schaffen, die potenziell eine Bedrohung für die Macht darstellen. Da wir aber Programmierer sind, interessiert uns nur die technische Interpretation dieses Prinzips. Und es geht so: „Das Prinzip von „Teile und herrsche“ besteht darin, ein großes Problem in kleinere zu zerlegen, bis sie elementar werden. Dann müssen Sie sie nacheinander lösen und alles zu einem Gesamtsystem kombinieren. Dieses Programm sollte das gegebene Problem lösen.“ Das heißt, Sie zerlegen einfach ein großes Problem in kleinere, die für Sie kein zu lösendes Problem sind. Und dann sammeln Sie die Lösung in einem großen. Um diesem einfachen und nützlichen Prinzip zu folgen, verwendet die Java-Programmierung Methoden. Wir erschaffen zum Beispiel einen Roboterboxer. Für uns ist es wichtig, dass er sich gut bewegt, präzise Schläge ausführt und auch den Feind auf der Suche nach Schwachstellen beobachtet. Es wäre doch umständlich, das alles in einer Hauptmethode zu schreiben , oder? Wenn wir alles in einer Methode beschreiben, sieht es ungefähr so ​​aus:

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

Was ist, wenn wir an anderer Stelle im Programm einen Schritt nach vorne machen oder einen Kick machen müssen? Alle Aktionen noch einmal beschreiben? Ungeeignet. Es gibt zu viele sich wiederholende Zeilen, in denen man sich leicht verlieren kann. Wir müssen die Beschreibung der Aktionsdetails in einem separaten Modul platzieren, das den Roboterschritt ausführt. Und wir können die Methode in einer Zeile aufrufen. Irgendwie so:

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

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

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

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

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

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

Jetzt haben wir die Roboterfunktionalität getrennt sowie eine kompakte und übersichtliche main()- Methode . Auch die restlichen Methoden können in beliebige Funktionalitäten unterteilt werden, beispielsweise kann deceptiveAttackingStrike in die Methoden deceptiveMovement , Leg Movement , attack unterteilt werden . Und ihnen werden wiederum einfachere Aufgaben zugewiesen, um letztendlich eine Reihe elementarer Aufgaben zu erhalten. Okay, jetzt schreiben wir alles schön in einer Form, die Java akzeptiert.

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() {
    	// Метод проверяет, атакует ли враг. kehrt zurück логическое Bedeutung.
    	return true;
}

Ich verstehe, dass Ihnen dieser Code jetzt vielleicht etwas unklar ist, insbesondere einige Wörter wie void , return usw. Beeilen Sie sich nicht, Tomaten zu werfen, ich erkläre jetzt alles. Die allgemeine Idee des „Teile und herrsche“-Paradigmas sollte Ihnen klar sein. Methoden werden uns dabei helfen. Die allgemeine Struktur von Methodendeklarationen ist wie folgt:

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

Zugriffsmodifikator

Der Zugriffsmodifikator besteht aus mehreren Schlüsselwörtern: public , private , package . Diese Worte geben den Umfang der Methode an. Ich erkläre es einfach: Mit diesem Wort scheinen Sie einen Leckerbissen mit anderen zu teilen. Lecker ist deine Methode. Wenn es private ist , teilen Sie die Methode nicht mit anderen Klassen. Wenn package , teilen Sie es nur mit Klassen innerhalb des Pakets (Klassen werden in bestimmten Paketen zusammengefasst, das erfahren Sie später). Nun, die Öffentlichkeit zeigt, dass Sie selbst Freundlichkeit sind und eine köstliche Leckerei (Methode) mit dem gesamten Programm teilen. Irgendwie so. Nach ein paar Leveln werden Sie die Rolle dieser Wörter viel besser verstehen.

Rückgabewert

Schauen Sie sich das obige Beispiel an: Alle Methoden sind mit dem Schlüsselwort void gekennzeichnet , mit Ausnahme einer – isEnemyAttacked , die einen booleschen Wert zurückgibt . Wenn eine Methode als void markiert ist , gibt sie möglicherweise nichts zurück. Diese Methode führt einfach eine Reihe von Aktionen aus und das war’s. Achten Sie nun auf die Hauptmethode . Die Methoden, die void zurückgeben , werden einfach so im Methodenkörper aufgerufen. Die Methode isEnemyAttacked wird jedoch innerhalb der Klammern der if- Anweisung aufgerufen . Dadurch, dass es einen booleschen Wert zurückgibt, erhalten wir die Möglichkeit, keine Zwischenvariable zu verwenden, sondern diese direkt einzufügen. Die Rückgabe eines Werts erfolgt über das Schlüsselwort return . Wenn eine Methode den Typ int zurückgibt , können wir die Methode von jedem Ausdruck aus aufrufen:

public static int getNumber() {
 	    return 5;
}

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

Abschluss: Die getNumber- Methode gibt einen int- Wert zurück , sodass wir ihn aus einem Ausdruck aufrufen können. Außerdem kann die Methode jeden Typ zurückgeben, auch solche, die Sie selbst erstellt haben. Wenn Sie einen Rückgabetyp für eine Methode angegeben haben, müssen Sie etwas zurückgeben. So kann man es nicht schreiben:

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

Der Compiler wird Ihnen sagen, dass Sie etwas zurückgeben, wenn die erste Bedingung erfüllt ist, aber wenn die zweite Bedingung erfüllt ist, nicht.

Übergabe von Parametern

Sie können der Methode Parameter übergeben, die während ihres Betriebs verwendet werden. Das primitivste Beispiel ist die Summation zweier Zahlen. Aber wir sind doch nicht primitiv, oder? Nehmen wir ein anderes, recht stereotypisches Beispiel. Nehmen wir an, wir haben eine Methode chef() - Cook. Wir können die Suppenzutaten im Parameterblock an diese Methode übergeben, und als Ergebnis gibt diese Methode die Suppe an uns zurück. So:

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

}

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

(Nehmen wir an, wir haben eine vorab erstellte Suppenklasse .) In der Hauptmethode erstellen wir eine Reihe von Zutaten und „geben sie dann an den Koch“ (übergeben Sie sie an die Kochmethode ). „Der Koch macht die Suppe“ und gibt sie uns dann als Objekt der Soup- Klasse zurück . Alles ist sehr einfach. Sie können beliebige Parameter, Grundtypen, Objekte, Arrays usw. an die Methode übergeben.

Übergabe von Parametern als Referenz und als Wert

In der Programmiersprache Java werden beliebige Parameter anhand ihres Werts an eine Methode übergeben. Dieser Mechanismus unterscheidet sich jedoch für primitive Typen und für Objekte. Wenn Sie einen primitiven Typ an eine Methode übergeben und ihn ändern, wird er in der Hauptmethode nicht geändert. Sie haben einfach eine Kopie des Werts übergeben und die ursprüngliche Variable blieb erhalten. Das einfachste Beispiel:

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

Abschluss: Bei Objekten wirken sich Änderungen jedoch auf das ursprüngliche Objekt aus:

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

Abschluss: Wir haben eine WiseMan- Klasse , die über eine iq- Eigenschaft verfügt . Und zwei Methoden, die den Wert dieses Feldes steuern. In der Hauptmethode erstellen wir ein wiseMan- Objekt und setzen den iq-Wert auf 300 . Dann übergeben wir unseren Sage mit iq 300 an die changeObject- Methode. Aber in dieser Methode wird er dumm. Wir setzen den Wert von iq auf 100. Dann drucken wir in der Hauptmethode das Objekt aus. Sie können sehen, dass wir in der Methode „changeObject“ einen anderen Sage in der Variablen m manipulieren . Wir modifizieren jedoch unser ursprüngliches Objekt. Tatsache ist, dass das wiseMan- Objekt in der Hauptmethode und das m- Objekt in der changeObject- Methode derselbe weise Mann sind und ein Verweis auf das Objekt als Parameter in die Methode kopiert wird. Beachten Sie dies, wenn Sie ein Objekt in einzelnen Methoden bearbeiten.

Abschließend noch ein paar Worte zum statischen Modifikator

Im Allgemeinen reichen ein paar Worte hier nicht aus, aber ich werde es versuchen. Reguläre Methoden, die nicht mit diesem Modifikator gekennzeichnet sind, gehören zum Klassenobjekt. Und statische Methoden gehören zur Klasse selbst. Auf einzelne Objekte können herkömmliche Methoden angewendet werden. Schauen Sie sich die WiseMan- Klasse aus dem obigen Beispiel an. Jeder Weise verfügt über seine eigenen getIq- und setIq- Methoden , da jeder IQ-Level unterschiedlich ist. Wenn wir dieser Klasse eine statische Methode „generateAWisePhrase“ hinzufügen , können wir eine solche Methode ohne Objekt aufrufen:

WiseMan.generateAWisePhrase();

Im Allgemeinen reichen diese Informationen vorerst aus, da über Statik mehrere Vorträge geschrieben werden können . Befolgen Sie beim Schreiben einer Methode einige Regeln, um die Ordnung in Ihrem Code aufrechtzuerhalten:

• Geben Sie Ihren Methoden aussagekräftige Namen, damit klar ist, was sie tun.
• Versuchen Sie, keine sehr langen Methoden zu schreiben. Die optimale Länge beträgt 8-15 Zeilen.
• Die Anzahl der Methodenparameter sollte 4-5 nicht überschreiten.
• Wenn Ihr Code zweimal eine ähnliche Funktionalität enthält, überlegen Sie: Vielleicht lohnt es sich, sie zu verallgemeinern und in eine separate Methode zu packen?

Diese Techniken helfen Ihnen, die Leistung Ihres Programms zu verbessern und, was am wichtigsten ist, Ihren Code besser lesbar zu machen.