1.3 Methodes et `static`

En Java on parle de methodes plutot que de fonctions — elles sont toujours attachees a une classe.

1. Anatomie d'une methode

visibilite  static?  retour    nom        (parametres)
public      static   void      main       (String[] args)
public               int       additionner(int a, int b)
private              String    formater   (String texte)

Exemple complet :

public class Calculatrice {

    public int additionner(int a, int b) {
        return a + b;
    }

    public void afficher(String message) {
        System.out.println(message); // void = pas de retour
    }
}

2. `static` vs non-`static`

C'est une distinction fondamentale en Java :

	static	non-static
Appartient a	La classe	L'instance (l'objet)
Existe sans	Oui, sans `new`	Non, besoin de `new`
Appel	`MaClasse.methode()`	`monObjet.methode()`

public class Compteur {
    private int valeur = 0;                  // non-static : propre a chaque instance
    private static int nombreInstances = 0; // static : partage par toutes les instances

    public void incrementer() {   // non-static : besoin d'un objet
        valeur++;
    }

    public static int getNombreInstances() { // static : appel direct sur la classe
        return nombreInstances;
    }
}

// Usage
Compteur c1 = new Compteur();
c1.incrementer();              // appel non-static : sur l'instance

Compteur.getNombreInstances(); // appel static : sur la classe directement

Pourquoi main est static ?
Java doit pouvoir lancer le programme SANS creer d'objet au prealable. static lui permet d'appeler main() directement sur la classe.

3. Surcharge (overloading)

Java n'a pas de valeurs par defaut pour les parametres (contrairement a PHP/Python). La surcharge compense : meme nom de methode, signatures differentes.

public class Afficheur {

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

    public void afficher(String message, int fois) { // meme nom, parametres differents
        for (int i = 0; i < fois; i++) {
            System.out.println(message);
        }
    }
}

// Usage
Afficheur a = new Afficheur();
a.afficher("Hello");        // appelle la premiere
a.afficher("Hello", 3);     // appelle la deuxieme

4. Le mot-cle `this`

this designe l'instance courante. Utile quand un parametre a le meme nom qu'un attribut.

public class Utilisateur {
    private String nom;

    public Utilisateur(String nom) {
        this.nom = nom; // "this.nom" = l'attribut, "nom" = le parametre
    }
}

this n'est obligatoire que s'il y a ambiguite. Sinon on peut s'en passer.

JBDC — Etape 1.3

On configure log4j2 et on modifie App.java pour logger au demarrage.

Creer app/src/main/resources/log4j2.xml :

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss} [%-5level] %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

log4j separe deux responsabilites :

Appender = la destination des logs. Console = le terminal, comme console.log en JS. On pourrait aussi avoir un appender File pour ecrire dans un fichier.
Logger = le filtre par classe. Dans log4j, chaque classe a son propre logger identifie par son nom :
LogManager.getLogger(App.class) cree le logger "jbdc.App"
LogManager.getLogger(Transfert.class) cree le logger "jbdc.service.Transfert"
Ces loggers forment un arbre base sur les packages. Root est la racine de cet arbre — le logger par defaut qui s'applique a toutes les classes si aucune regle plus specifique n'existe.

AppenderRef connecte les deux : il dit au Logger Root "envoie tout ce que tu acceptes vers l'appender Console".

Element	Role
`Configuration status="WARN"`	Niveau des logs internes de log4j lui-meme (pas de ton app)
`Appenders > Console`	Destination : ecrit sur le terminal, comme `console.log` en JS
`PatternLayout`	Format de chaque ligne de log
`Root level="info"`	Pour toutes les classes : laisse passer INFO, WARN, ERROR — bloque DEBUG
`AppenderRef ref="Console"`	Envoie les messages acceptes par Root vers l'appender Console

Le pattern %d{HH:mm:ss} [%-5level] %logger{36} - %msg%n produit :

14:32:07 [INFO ] jbdc.App - JBDC demarre...

Comparaison Go : C'est l'equivalent de slog.New(slog.NewTextHandler(...)) configure une fois, utilise partout via une variable globale.

Puis modifier App.java — notez le Logger static : il appartient a la classe, pas a une instance.

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class App {
    private static final Logger logger = LogManager.getLogger(App.class);

    public static void main(String[] args) {
        logger.info("JBDC demarre...");
    }
}

git commit -m "feat(phase-1): add log4j2 + startup log"

IDE qui se plaint apres ajout d'une dependance ?
Le Language Server Java ne recharge pas toujours le classpath automatiquement. Lancer d'abord le build Gradle pour telecharger les JARs, puis recharger la fenetre :

.\gradlew build

Puis Ctrl+Shift+P → Developer: Reload Window.

Precedent : Types et Variables Suivant : Conditions

1.3 Methodes et static