06 - Méthodes (Fonctions)

Les méthodes sont des blocs de code réutilisables qui effectuent des tâches spécifiques. Elles vous évitent de réécrire du code et rendent votre code plus simple à comprendre.

Qu'est-ce qu'une méthode ?

Une méthode est un peu comme une recette. Vous la définissez une fois, puis vous pouvez l'utiliser à chaque fois que vous en avez besoin.

public class Jeu {
   public static void main(String[] args) {
       salutation();           // Appelle la méthode
       salutation();           // L'appelle à nouveau
   }

   // Définition de la méthode
   public static void salutation() {
      System.out.println("Bienvenue sur Hytale !");
   }
}

Structure d'une méthode

public static void methodName() {
//  ^     ^     ^      ^       ^
//  |     |     |      |       |
//  |    static |     nom  paramètres
// modificateur type de
// d'accès      retour
    // Insérez le code ici
}

Nous allons apprendre ce que signifient public et static plus tard. Pour l'instant, utilisez-les.

Méthodes avec paramètres

Les paramètres vous permettent de passer des données dans des méthodes :

public static void saluerJoueur(String name) {
   System.out.println("Bonjour, " + name + " !");
}

public static void main(String[] args) {
   saluerJoueur("Alice");   // Bonjour, Alice !
   saluerJoueur("Bob");     // Bonjour, Bob !
}

Plusieurs paramètres

public static void faireDesDegats(String cible, int degat) {
   System.out.println(cible + " prend " + degat+ " dégâts !");
}

public static void main(String[] args) {
   faireDesDegats("Zombie", 20);       // Zombie prend 20 dégâts !
   faireDesDegats("Squelette", 15);   // Squelette prend 15 dégâts !
}

L'ordre des paramètres est important

Lors de l'appel d'une méthode, les arguments doivent correspondre à l'ordre des paramètres :

public static void creerUnObjet(String nom, int quantite, double prix) {
   // ...
}

// Correct
creerUnObjet("Épée", 1, 50.0);

// Incorrect - L'ordre importe !
creerUnObjet(1, "Épée", 50.0);   // Erreur !

Méthodes avec des valeurs de retour

Les méthodes peuvent renvoyer des données en utilisant return

public static int ajouter(int a, int b) {
   int somme = a + b;
   return somme;
}

public static void main(String[] args) {
   int resultat = ajouter(5, 3);
   System.out.println(resultat);   // 8
}

Le type de retour de la méthode doit correspondre à ce que vous retournez réellement :

void - Ne revoie rien
int - Renvoie un entier
double - Renvoie un nombre décimal
boolean - Renvoie true/false (vrai/faux)
String - Renvoie du texte

public static String obtenirNomObjet() {
   return "Épée en diamant";
}

public static boolean joueurEnVie(int vie) {
   return vie > 0;
}

public static double calculerDegats(int attaque, double multiplicateur) {
    return attaque * multiplicateur;
}

Le renvoi arrête l'exécution

Une fois que la méthode arrive à return, elle se termine immédiatement. Tout le code après return ne sera pas exécuté !

public static int obtenirValeur() {
   return 10;
   System.out.println("Ceci ne s'exécute jamais !")   // Code inatteignable !
}

Exemple

Système de santé

public static void afficheSante(String nom, int vie, int vieMax) {
   double pourcentage = (vie * 100.0) / vieMax;
   System.out.println(nom + ": " + vie + "/" + vieMax + 
                      " (" + pourcentage+ "%)");
}

public static void main(String[] args) {
    afficheSante("Joueur", 75, 100);
    afficheSante("Boss", 450, 500);
}

Calculateur de dégâts

public static int calculerDegats(int attaqueBase, int degatArme, boolean estCritique) {
    int degatsTotal = attaqueBase + degatArme;
    
    if (estCritique) {
        degatsTotal *= 2;
    }
    
    return degatsTotal ;
}

public static void main(String[] args) {
    int degats1 = calculerDegats(10, 15, false);  // 25
    int degats2 = calculerDegats(10, 15, true);   // 50
    
    System.out.println("Coup normal : " + degats1);
    System.out.println("Coup critique : " + degats2);
}

Niveau requis

public static int avoirExpPourNiveau(int niveau) {
    return niveau * 100;
}

public static boolean peutNiveauSup(int expActuelle, int niveauActuel) {
    int requis = avoirExpPourNiveau(niveauActuel + 1);
    return expActuelle >= requis;
}

public static void main(String[] args) {
    int expJoueur = 450;
    int joueurNiveau = 4;
    
    if (peutNiveauSup(expJoueur, joueurNiveau)) {
        System.out.println("Vous pouvez monter de niveau !");
    } else {
        int necessaire = avoirExpPourNiveau(niveauJoueur + 1) - expJoueur;
        System.out.println("Besoin de " + necessaire + " points d'expérience en plus");
    }
}

Calculateur de distance

public static double calculerDistance(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1;
    int dy = y2 - y1;
    return Math.sqrt(dx * dx + dy * dy);
}

public static boolean estAPortee(int x1, int y1, int x2, int y2, double portee) {
    double distance = calculerDistance(x1, y1, x2, y2);
    return distance <= portee;
}

public static void main(String[] args) {
    // Vérifie si un ennemi est à portée d'attaque
    if (estAPortee(0, 0, 5, 5, 10.0)) {
        System.out.println("Cible à portée !");
    }
}

Surcharge de méthode

Vous pouvez définir plusieurs méthodes avec le même nom mais avec des paramètres différents :

public static void afficherMessage(String message) {
    System.out.println(message);
}

public static void afficherMessages(String message, int fois) {
    for (int i = 0; i < fois; i++) {
        System.out.println(message);
    }
}

public static void main(String[] args) {
    afficherMessages("Bonjour");           // Appelle la première version
    afficherMessages("Bonjour", 3);        // Appelle la seconde version
}

Règles de la surcharge de méthode

Les méthodes ayant le même nom sont considérées comme différentes si elles ont :

Un nombre différent de paramètres
Des types de paramètres différents
Un ordre de paramètres différents

public static void test(int a) { }
public static void test(int a, int b) { }        // Nombre de paramètres différent
public static void test(double a) { }            // Type différent
public static void test(String a, int b) { }     // Types différents
public static void test(int a, String b) { }     // Ordre différent

// Incorrect - Seul le type de retour est différent
public static int test(int a) { }

Schémas communs dans le Modding de Hytale

Création d'objet

public static Item creeObjet(String nom, int durabilite) {
    Item objet = new Item();
    item.setName(nom);
    item.setDurability(durabilite);
    return item;
}

public static Item creeEpee() {
    return creeObjet("Épée", 100);
}

public static Item creePioche() {
    return creeObjet("Pioche", 150);
}

Validation du placement de bloc

public static boolean peutPoserBloc(int x, int y, int z) {
    // Vérifie si la position est valide
    if (y < 0 || y > 255) {
        return false;
    }
    
    // Vérifie si le bloc existe déjà
    if (blocPresentEn(x, y, z)) {
        return false;
    }
    
    return true;
}

public static void poserBloc(int x, int y, int z, String type) {
    if (peutPoserBloc(x, y, z)) {
        // Place le bloc
        System.out.println("Bloc posé " + type + " en (" + x + ", " + y + ", " + z + ")");
    } else {
        System.out.println("On ne peut pas poser de bloc ici !");
    }
}

Vérifications de l'état du joueur

public static boolean vieEstFaible(int vie, int vieMax) {
    return (vie * 100.0 / vieMax) < 25;
}

public static String obtenirStatutDeVie(int vie, int vieMax) {
    double pourcentage = (vie * 100.0) / vieMax;
    
    if (pourcentage >= 75) {
        return "En bonne santé";
    } else if (pourcentage >= 50) {
        return "Blessé";
    } else if (pourcentage >= 25) {
        return "État critique";
    } else {
        return "Proche de la mort";
    }
}

Bonnes pratiques

Nommage des méthodes

Utilisez des noms basés sur des verbes descriptifs qui expliquent ce que la méthode fait :

// Bon noms
public static void calculerDegats() { }
public static boolean joueurEnVie() { }
public static String obtenirNomObjet() { }
public static void afficherInventaire() { }

// Mauvais noms
public static void dgt() { }        // Trop court
public static void methode1() { }    // Pas descriptif
public static void equipement() { }      // Trop vague

Exercices pratiques

Convertisseur de températures : écrivez une méthode qui convertit :
- Les degrés Celsius en degrés Fahrenheit : (C × 9/5) + 32
- Les degrés Fahrenheit en degrés Celsius : (F - 32) × 5/9
Calculateur de cercle : écrivez une méthode qui calcule :
- L'aire : π × rayon²
- La circonférence : 2 × π × rayon
- Utilisez Math.PI pour π
Durabilité des objets : écrivez ces méthodes :
- abimerObjet(int actuel, int degat) - renvoie la nouvelle durabilité
- estCasse(int durabilite) - renvoie vrai si la durabilité est inférieure ou égale à 0
- reparerObjet(int actuel, int max) - renvoie la durabilité maximum
Validateur de mot de passe : créez une méthode qui vérifie si un mot de passe est valide :
- Au moins 8 caractères
- Contient au moins un chiffre
- Renvoie vrai si valide, faux sinon

Erreurs courantes

// Incorrect - Oubli de l'instruction return
public static int obtenirValeur() {
    int x = 10;
    // Oubli de retourner !
} !

// Correct
public static int obtenirValeur() {
    int x = 10;
    return x;
}

// Incorrect - Mauvais type de retour
public static int obtenirTexte() {
    return "Bonjour";  // Erreur ! Doit retourner un int, pas un String
}

// Correct
public static String obtenirTexte() {
    return "Bonjour";
}

// Incorrect - N'appelle pas la méthode
public static void main(String[] args) {
    saluer;  // Erreur ! Oubli de ()
}

// Correct
public static void main(String[] args) {
    saluer();
}

06 - Méthodes (Fonctions)

On this page