Méthodes en Java

Il existe un principe intéressant dont beaucoup ont entendu parler. Cela s'appelle « Diviser pour régner ». Ce principe est utilisé dans de nombreux domaines de la vie humaine, par exemple en politique. Cela dénote la division d’un grand nombre de parties hétérogènes de l’État, incitant et utilisant l’hostilité entre ces parties. En d’autres termes : créer un conflit entre ceux qui constituent potentiellement une menace pour le pouvoir. Mais nous sommes des programmeurs, nous ne nous intéressons donc qu’à l’interprétation technique de ce principe. Et cela ressemble à ceci : « Le principe de « Diviser pour régner » est de diviser un gros problème en problèmes plus petits jusqu'à ce qu'ils deviennent élémentaires. Ensuite, vous devez les résoudre séquentiellement et tout combiner en un seul système. Ce programme devrait résoudre le problème donné. » Autrement dit, vous divisez simplement un gros problème en problèmes plus petits, qui ne sont pas un problème à résoudre. Et puis vous rassemblez la solution en une seule grande. Pour suivre ce principe simple et utile, la programmation Java utilise des méthodes. Par exemple, nous créons un robot boxeur. Il est important pour nous qu'il bouge bien, qu'il effectue des frappes précises et qu'il surveille également l'ennemi à la recherche de points faibles. Ce serait gênant d'écrire tout cela dans une seule méthode principale , n'est-ce pas ? Si nous décrivons tout en une seule méthode, cela ressemblera à ceci :

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

Que se passe-t-il si nous devons utiliser un pas en avant ou un coup de pied ailleurs dans le programme ? Décrivez à nouveau toutes les actions ? Ne convient pas. Il y a trop de lignes répétées dans lesquelles il est facile de se perdre. Nous devons placer la description des détails de l'action dans un module séparé, qui effectuera l'étape du robot. Et nous pouvons appeler la méthode sur une seule ligne. Quelque chose comme ça:

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

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

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

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

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

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

Nous avons maintenant des fonctionnalités de robot séparées, ainsi qu'une méthode main() compacte et claire . Le reste des méthodes peut également être divisé en n'importe quelle fonctionnalité, par exemple, deceptiveAttackingStrike peut être divisé en méthodes deceptiveMovement , Leg Movement , Attack . Et eux, à leur tour, sont affectés à des tâches plus simples afin d'obtenir finalement un ensemble de tâches élémentaires. Bon, écrivons maintenant tout cela magnifiquement sous une forme que Java acceptera.

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

Je comprends que ce code peut être un peu flou pour vous maintenant, en particulier certains mots comme void , return et ainsi de suite. Ne vous précipitez pas pour jeter des tomates, je vais tout vous expliquer maintenant. L’idée générale du paradigme « Diviser pour régner » devrait être claire pour vous. Les méthodes nous y aideront. La structure générale des déclarations de méthodes est la suivante :

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

Modificateur d'accès

Le modificateur d'accès est constitué de plusieurs mots-clés : public , private , package . Ces mots indiquent la portée de la méthode. Je vais l’expliquer simplement : avec ce mot, vous semblez partager une gourmandise avec les autres. Miam est votre méthode. Si c'est private , vous ne partagez pas la méthode avec d'autres classes. Si package , vous partagez uniquement avec les classes du package (les classes sont collectées dans des packages spécifiques, vous l'apprendrez plus tard). Eh bien, montrez au public que vous êtes la gentillesse même et partagez une délicieuse gâterie (méthode) avec l'ensemble du programme. Quelque chose comme ça. Après quelques niveaux vous comprendrez bien mieux le rôle de ces mots.

Valeur de retour

Regardez l'exemple ci-dessus : toutes les méthodes sont marquées avec le mot-clé void , à l'exception d'une - isEnemyAttacked , qui renvoie une valeur booléenne . Si une méthode est marquée void , elle ne peut rien renvoyer. Cette méthode effectue simplement un ensemble d’actions et c’est tout. Maintenant, faites attention à la méthode principale . Les méthodes qui renvoient void sont appelées comme ça, dans le corps de la méthode. Mais la méthode isEnemyAttacked est appelée entre parenthèses de l' instruction if . Du fait qu'il renvoie une valeur booléenne, nous avons la possibilité de ne pas utiliser de variable intermédiaire, mais de l'insérer directement. Le renvoi d'une valeur s'effectue à l'aide du mot-clé return . Si une méthode renvoie le type int , nous pouvons appeler la méthode à partir de n'importe quelle expression :

public static int getNumber() {
 	    return 5;
}

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

Conclusion: La méthode getNumber renvoie une valeur int , nous pouvons donc l'appeler à partir d'une expression. En outre, la méthode peut renvoyer n’importe quel type, y compris ceux que vous avez créés vous-même. Si vous avez spécifié un type de retour pour une méthode, vous devez alors renvoyer quelque chose. Vous ne pouvez pas l'écrire comme ceci :

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

Le compilateur vous grondera en disant que lorsque la première condition est remplie, vous renvoyez quelque chose, mais que lorsque la deuxième condition est remplie, vous ne le faites pas.

Passer des paramètres

Vous pouvez transmettre des paramètres à la méthode qui sont utilisés lors de son fonctionnement. L'exemple le plus primitif est la sommation de deux nombres. Mais nous ne sommes pas primitifs, n'est-ce pas ? Prenons un autre exemple, assez stéréotypé. Disons que nous avons une méthode chef() - cuisinier. Nous pouvons transmettre les ingrédients de la soupe à cette méthode dans le bloc de paramètres, et par conséquent, cette méthode nous renvoie la soupe. Comme ça:

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

}

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

(Disons que nous avons une classe Soup pré-créée ) Dans la méthode principale, nous créons un tableau d'ingrédients puis « le donnons au chef » (le transmettons à la méthode chef ). « Le cuisinier fait la soupe » puis nous la rend comme objet du cours Soupe . Tout est très simple. Vous pouvez transmettre n'importe quel paramètre, type primitif, objet, tableau, etc. à la méthode.

Passer des paramètres par référence et par valeur

Dans le langage de programmation Java, tous les paramètres sont transmis à une méthode par leur valeur. Cependant, ce mécanisme est différent pour les types primitifs et pour les objets. Si vous transmettez un type primitif dans une méthode et que vous le modifiez, il ne changera pas dans la méthode principale. Vous avez simplement transmis une copie de la valeur et la variable d'origine a été conservée. L'exemple le plus simple :

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

Conclusion: Cependant, dans le cas d'objets, les modifications affectent l'objet d'origine :

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

Conclusion: Nous avons une classe WiseMan qui possède une propriété iq . Et deux méthodes qui contrôlent la valeur de ce champ. Dans la méthode principale, nous créons un objet wiseMan , définissons la valeur iq sur 300 . Ensuite, nous transmettons notre sage avec iq 300 à la méthode changeObject . Mais dans cette méthode, il devient stupide. Nous fixons la valeur de iq à 100. Ensuite, dans la méthode principale, nous imprimons l'objet. Vous pouvez voir que dans la méthode changeObject , nous manipulons un autre sage dans la variable m . Cependant, nous modifions notre objet d'origine. Le fait est que l' objet wiseMan dans la méthode main et l' objet m dans la méthode changeObject sont le même sage, et une référence à l'objet est copiée dans la méthode en tant que paramètre. Gardez cela à l'esprit lorsque vous modifiez un objet dans des méthodes individuelles.

Enfin, quelques mots sur le modificateur static

En général, quelques mots ne suffiront pas ici, mais je vais essayer. Les méthodes régulières non marquées par ce modificateur appartiennent à l'objet de classe. Et les méthodes statiques appartiennent à la classe elle-même. Les méthodes conventionnelles peuvent être utilisées sur des objets individuels. Regardez la classe WiseMan à partir de l'exemple ci-dessus. Chaque sage aura ses propres méthodes getIq et setIq , car le niveau de QI de chacun est différent. Si nous ajoutons une méthode statique generateAWisePhrase à cette classe , alors nous pouvons appeler une telle méthode sans objet :

WiseMan.generateAWisePhrase();

En général, ces informations sont suffisantes pour l'instant, car plusieurs conférences peuvent être écrites sur le static . Suivez quelques règles lorsque vous écrivez une méthode pour maintenir l'ordre dans votre code :

• Donnez à vos méthodes des noms significatifs afin que ce qu'elles font soit clair.
• Essayez de ne pas écrire de méthodes très longues. La longueur optimale est de 8 à 15 lignes.
• Le nombre de paramètres de méthode ne doit pas dépasser 4 à 5.
• Si vous avez deux fois des fonctionnalités similaires dans votre code, réfléchissez : peut-être vaut-il la peine de la généraliser et de la placer dans une méthode distincte ?

Ces techniques vous aideront à améliorer les performances de votre programme et, surtout, à rendre votre code plus lisible.