Méthodes et Surcharge

Les méthodes définissent le comportement d'un objet. Nous pouvons les voir comme des fonctions déclarées à l'intérieur d'une classe qui opèrent sur les champs d'instance de l'objet ou sur les paramètres d'entrée.

Définir une Méthode

Une méthode en Java est composée de :

1. Modificateur d'accès (ex. public, private).
2. Type de retour (ex. int, String, ou void s'il ne renvoie rien).
3. Nom de la méthode en camelCase.
4. Paramètres entourés de parenthèses.
5. Corps de la méthode entouré d'accolades.

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    // Metodo con tipo di ritorno String
    public String greet() {
        return "Ciao, mi chiamo " + name;
    }
}

Appeler une Méthode

Pour appeler une méthode sur un objet créé, nous utilisons la syntaxe du point .:

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Marco");
        String message = p.greet(); // Chiamata del metodo
        System.out.println(message);
    }
}

Surcharge des Méthodes (Method Overloading)

En Java, deux ou plusieurs méthodes au sein de la même classe peuvent avoir le même nom, à condition d'avoir une liste de paramètres différente (par le nombre, l'ordre ou le type des paramètres). Ce concept est connu sous le nom de Surcharge (Overloading).

Le compilateur décidera quelle méthode appeler en analysant les arguments passés lors de l'appel.

class Printer {
    // Metodo per stampare un intero
    public void printValue(int number) {
        System.out.println("Intero: " + number);
    }

    // Metodo sovraccaricato per stampare una stringa
    public void printValue(String text) {
        System.out.println("Testo: " + text);
    }
}

Passage des Paramètres par Valeur

En Java, tous les paramètres sont passés par valeur (pass-by-value). Cela signifie que lorsqu'un argument est passé à une méthode, Java crée une copie de la valeur de la variable et la passe à la méthode.

• Pour les types primitifs, la valeur d'origine en dehors de la méthode ne change jamais, même si elle est modifiée à l'intérieur de la méthode.
• Pour les objets/références, c'est la référence à l'objet qui est copiée. Cela signifie que, bien que nous ne puissions pas changer l'adresse pointée par l'objet d'origine, nous pouvons modifier son état interne (ex. ses champs) et les modifications seront visibles en dehors.

Limites de la Surcharge : Le Type de Retour

Il est important de souligner qu'il n'est pas possible de surcharger une méthode en se basant uniquement sur son type de retour. Par exemple, le code suivant générera une erreur de compilation :

class Example {
    // ERRORE: La firma dei due metodi è considerata identica
    public int getNumber() { return 42; }
    public double getNumber() { return 42.0; }
}

Le compilateur a besoin de distinguer les méthodes uniquement en fonction de leurs paramètres pour décider quelle version appeler à la compilation (la surcharge est entièrement résolue au moment de la compilation).

À vous de jouer