Java pour développeur PHP : les différences clés, en pratique

PHP et Java se ressemblent plus qu’on ne le croit : syntaxe héritée du C, classes, interfaces, exceptions, et même les mots-clés public, private, static ou final. PHP moderne a d’ailleurs emprunté beaucoup à Java (types, interfaces, énumérations). Pourtant, les premières semaines sont souvent déroutantes : le compilateur refuse ton code, les tableaux n’ont rien à voir, et ton application ne « meurt » plus à la fin de chaque requête.

Ce guide est pensé pour un développeur PHP qui découvre Java : on part de ce que tu connais pour arriver à son équivalent, en expliquant le pourquoi des différences. À la fin, tu sauras lire et écrire du Java idiomatique, et tu sauras quoi installer pour démarrer.

Différence n°1 : le modèle d’exécution

C’est la différence la plus profonde, et celle dont on parle le moins. En PHP, chaque requête HTTP lance ton script, qui répond puis disparaît avec toutes ses variables. En Java, l’application démarre une seule fois dans la JVM (machine virtuelle Java) et reste en mémoire pour traiter toutes les requêtes, en parallèle.

Différence n°2 : le typage statique et la compilation

PHP est dynamiquement typé (même si les types déclarés de PHP 7 et 8 ont beaucoup réduit l’écart). Java est statiquement typé : chaque variable a un type connu à la compilation, et le compilateur refuse le code incohérent avant qu’il ne s’exécute.

<?php
$prenom = "Alice";
$age = 31;
$age = "trente et un";        // autorisé : la variable change de type

function saluer(string $nom): string {
    return "Salut $nom";
}
echo saluer($prenom);

<?php
$prenom = "Alice";
$age = 31;
$age = "trente et un";        // autorisé : la variable change de type

function saluer(string $nom): string {
    return "Salut $nom";
}
echo saluer($prenom);

// Java 25 : un fichier source « compact », lancé avec  java Saluer.java
String saluer(String nom) {
    return "Salut " + nom;
}

void main() {
    String prenom = "Alice";
    int age = 31;
    // age = "trente et un";      // ❌ erreur de compilation : incompatible types

    var ville = "Liège";          // inférence de type : ville est un String, pour toujours

    IO.println(saluer(prenom) + " de " + ville + ", " + age + " ans");
}

// Java 25 : un fichier source « compact », lancé avec  java Saluer.java
String saluer(String nom) {
    return "Salut " + nom;
}

void main() {
    String prenom = "Alice";
    int age = 31;
    // age = "trente et un";      // ❌ erreur de compilation : incompatible types

    var ville = "Liège";          // inférence de type : ville est un String, pour toujours

    IO.println(saluer(prenom) + " de " + ville + ", " + age + " ans");
}

Le mot-clé var (Java 10+) évite de répéter le type quand il est évident, mais le typage reste statique : var n’est pas le $ de PHP. Côté workflow, Java ajoute une étape : le code source .java est compilé en bytecode .class, exécuté par la JVM. Les IDE et Maven/Gradle le font pour toi, et depuis Java 11 tu peux même lancer java Main.java directement.

Différence n°3 : tout est classe (ou presque)

En PHP, un fichier peut contenir des fonctions libres et du code exécuté directement. En Java classique, tout vit dans une classe, et un fichier public porte le nom de sa classe (Utilisateur.java contient public class Utilisateur). Les espaces de noms PHP deviennent des packages, qui correspondent aux dossiers.

<?php
namespace App\Modele;

final class Utilisateur
{
    public function __construct(
        private readonly string $nom,
        private readonly string $email,
    ) {}

    public function nom(): string { return $this->nom; }

    public function salutation(): string
    {
        return "Bonjour {$this->nom}";
    }
}

<?php
namespace App\Modele;

final class Utilisateur
{
    public function __construct(
        private readonly string $nom,
        private readonly string $email,
    ) {}

    public function nom(): string { return $this->nom; }

    public function salutation(): string
    {
        return "Bonjour {$this->nom}";
    }
}

package be.lmcode.modele;

public final class Utilisateur {
    private final String nom;
    private final String email;

    public Utilisateur(String nom, String email) {
        this.nom = nom;
        this.email = email;
    }

    public String getNom() { return nom; }

    public String salutation() {
        return "Bonjour " + nom;      // pas de $this-> : this est implicite
    }
}

package be.lmcode.modele;

public final class Utilisateur {
    private final String nom;
    private final String email;

    public Utilisateur(String nom, String email) {
        this.nom = nom;
        this.email = email;
    }

    public String getNom() { return nom; }

    public String salutation() {
        return "Bonjour " + nom;      // pas de $this-> : this est implicite
    }
}

Pour une simple classe de données, Java propose depuis la version 16 les records, l’équivalent des propriétés promues readonly de PHP 8, avec en prime equals(), hashCode() et toString() générés :

public record Utilisateur(String nom, String email) {
    public String salutation() {
        return "Bonjour " + nom;
    }
}

var alice = new Utilisateur("Alice", "alice@exemple.be");
IO.println(alice.nom());          // accesseur généré : nom(), pas getNom()
IO.println(alice);                // Utilisateur[nom=Alice, email=alice@exemple.be]

public record Utilisateur(String nom, String email) {
    public String salutation() {
        return "Bonjour " + nom;
    }
}

var alice = new Utilisateur("Alice", "[email protected]");
IO.println(alice.nom());          // accesseur généré : nom(), pas getNom()
IO.println(alice);                // Utilisateur[nom=Alice, [email protected]]

Différence n°4 : adieu le tableau à tout faire

En PHP, array sert à tout : liste, dictionnaire, pile, ensemble… En Java, chaque usage a sa structure, avec des performances garanties. C’est probablement le plus gros changement d’habitude.

<?php
$langages = ['PHP', 'Java', 'Python'];          // liste
$langages[] = 'Go';

$ages = ['Alice' => 31, 'Bruno' => 27];          // dictionnaire
$ages['Chloé'] = 35;

foreach ($ages as $nom => $age) {
    echo "$nom a $age ans\n";
}

$adultes = array_filter($ages, fn($a) => $a >= 30);
$noms = array_map('strtoupper', array_keys($adultes));

<?php
$langages = ['PHP', 'Java', 'Python'];          // liste
$langages[] = 'Go';

$ages = ['Alice' => 31, 'Bruno' => 27];          // dictionnaire
$ages['Chloé'] = 35;

foreach ($ages as $nom => $age) {
    echo "$nom a $age ans\n";
}

$adultes = array_filter($ages, fn($a) => $a >= 30);
$noms = array_map('strtoupper', array_keys($adultes));

import java.util.*;

List<String> langages = new ArrayList<>(List.of("PHP", "Java", "Python"));
langages.add("Go");

Map<String, Integer> ages = new HashMap<>(Map.of("Alice", 31, "Bruno", 27));
ages.put("Chloé", 35);

for (var e : ages.entrySet()) {
    IO.println(e.getKey() + " a " + e.getValue() + " ans");
}

List<String> noms = ages.entrySet().stream()
    .filter(e -> e.getValue() >= 30)
    .map(e -> e.getKey().toUpperCase())
    .toList();

import java.util.*;

List<String> langages = new ArrayList<>(List.of("PHP", "Java", "Python"));
langages.add("Go");

Map<String, Integer> ages = new HashMap<>(Map.of("Alice", 31, "Bruno", 27));
ages.put("Chloé", 35);

for (var e : ages.entrySet()) {
    IO.println(e.getKey() + " a " + e.getValue() + " ans");
}

List<String> noms = ages.entrySet().stream()
    .filter(e -> e.getValue() >= 30)
    .map(e -> e.getKey().toUpperCase())
    .toList();

Les fonctions array_filter, array_map et array_reduce trouvent leur équivalent dans l’API Stream (filter, map, reduce, collect). Et attention : List.of() et Map.of() créent des collections non modifiables, d’où le new ArrayList<>(...). Pour bien choisir entre ArrayList, HashMap, HashSet ou TreeMap, notre guide des collections Java détaille chaque structure avec schémas et complexités.

Différence n°5 : les chaînes et les comparaisons

String a = "bonjour";
String b = new String("bonjour");

IO.println(a == b);           // false ! == compare les références (les objets)
IO.println(a.equals(b));      // true  : compare le contenu

// Concaténation : + (pas de point comme en PHP)
String message = "Salut " + a + " !";

// Interpolation : String.format ou formatted()
String ligne = "%s a %d ans".formatted("Alice", 31);

// Text blocks (Java 15+) : l'équivalent du heredoc PHP
String html = """
    <p>Bonjour %s</p>
    """.formatted("Alice");

String a = "bonjour";
String b = new String("bonjour");

IO.println(a == b);           // false ! == compare les références (les objets)
IO.println(a.equals(b));      // true  : compare le contenu

// Concaténation : + (pas de point comme en PHP)
String message = "Salut " + a + " !";

// Interpolation : String.format ou formatted()
String ligne = "%s a %d ans".formatted("Alice", 31);

// Text blocks (Java 15+) : l'équivalent du heredoc PHP
String html = """
    <p>Bonjour %s</p>
    """.formatted("Alice");

Différence n°6 : null et Optional

PHP 8 a l’opérateur ?-> (nullsafe) et ??. Java n’a ni l’un ni l’autre, et appeler une méthode sur null lève la célèbre NullPointerException. Pour signaler qu’une méthode peut ne rien renvoyer, Java utilise Optional :

<?php
$ville = $utilisateur?->adresse?->ville ?? 'Inconnue';

<?php
$ville = $utilisateur?->adresse?->ville ?? 'Inconnue';

Optional<Utilisateur> trouve = depot.findByEmail("alice@exemple.be");

String ville = trouve
    .map(Utilisateur::adresse)
    .map(Adresse::ville)
    .orElse("Inconnue");

// Valeur par défaut simple
String nom = Objects.requireNonNullElse(saisie, "Anonyme");

Optional<Utilisateur> trouve = depot.findByEmail("[email protected]");

String ville = trouve
    .map(Utilisateur::adresse)
    .map(Adresse::ville)
    .orElse("Inconnue");

// Valeur par défaut simple
String nom = Objects.requireNonNullElse(saisie, "Anonyme");

Différence n°7 : les exceptions vérifiées

La gestion des exceptions ressemble beaucoup à PHP (try, catch, finally, throw), avec une particularité : les exceptions vérifiées (checked exceptions). Si une méthode peut lever une IOException, le compilateur t’oblige à la gérer ou à la déclarer avec throws.

// Le compilateur exige de traiter IOException
static String lireFichier(Path chemin) throws IOException {
    return Files.readString(chemin);
}

void main() {
    try {
        IO.println(lireFichier(Path.of("config.txt")));
    } catch (NoSuchFileException e) {
        IO.println("Fichier introuvable : " + e.getFile());
    } catch (IOException e) {
        IO.println("Erreur de lecture : " + e.getMessage());
    }
}

// try-with-resources : ferme automatiquement la ressource (comme un fclose garanti)
try (var lecteur = Files.newBufferedReader(Path.of("data.csv"))) {
    lecteur.lines().forEach(IO::println);
}

// Le compilateur exige de traiter IOException
static String lireFichier(Path chemin) throws IOException {
    return Files.readString(chemin);
}

void main() {
    try {
        IO.println(lireFichier(Path.of("config.txt")));
    } catch (NoSuchFileException e) {
        IO.println("Fichier introuvable : " + e.getFile());
    } catch (IOException e) {
        IO.println("Erreur de lecture : " + e.getMessage());
    }
}

// try-with-resources : ferme automatiquement la ressource (comme un fclose garanti)
try (var lecteur = Files.newBufferedReader(Path.of("data.csv"))) {
    lecteur.lines().forEach(IO::println);
}

Les exceptions qui héritent de RuntimeException (comme IllegalArgumentException) ne sont pas vérifiées : c’est l’équivalent des exceptions PHP habituelles. Spring Boot les utilise massivement.

Différence n°8 : match, enum et switch

Bonne surprise : l’expression match de PHP 8 a son jumeau en Java avec le switch moderne (Java 14+), et les énumérations PHP 8.1 ressemblent beaucoup aux enum Java.

<?php
enum Statut: string {
    case AFaire = 'a_faire';
    case EnCours = 'en_cours';
    case Terminee = 'terminee';
}

$libelle = match ($statut) {
    Statut::AFaire => 'À faire',
    Statut::EnCours => 'En cours',
    Statut::Terminee => 'Terminée',
};

<?php
enum Statut: string {
    case AFaire = 'a_faire';
    case EnCours = 'en_cours';
    case Terminee = 'terminee';
}

$libelle = match ($statut) {
    Statut::AFaire => 'À faire',
    Statut::EnCours => 'En cours',
    Statut::Terminee => 'Terminée',
};

enum Statut { A_FAIRE, EN_COURS, TERMINEE }

String libelle = switch (statut) {
    case A_FAIRE -> "À faire";
    case EN_COURS -> "En cours";
    case TERMINEE -> "Terminée";
};   // le compilateur vérifie qu'aucun cas n'est oublié

enum Statut { A_FAIRE, EN_COURS, TERMINEE }

String libelle = switch (statut) {
    case A_FAIRE -> "À faire";
    case EN_COURS -> "En cours";
    case TERMINEE -> "Terminée";
};   // le compilateur vérifie qu'aucun cas n'est oublié

Différence n°9 : les outils et l’écosystème Java pour développeur PHP

Tu ne repars pas de zéro : chaque outil de ton quotidien PHP a son équivalent Java.

Composer → Maven ou Gradle

Le composer.json devient un pom.xml (Maven) ou un build.gradle (Gradle). Ils gèrent les dépendances et la compilation, les tests et le packaging. Les bibliothèques viennent de Maven Central, l’équivalent de Packagist.

<dependencies>
    <!-- équivalent de : composer require laravel/framework -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- équivalent de : composer require --dev phpunit/phpunit -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<dependencies>
    <!-- équivalent de : composer require laravel/framework -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- équivalent de : composer require --dev phpunit/phpunit -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Laravel / Symfony → Spring Boot

Spring Boot est le framework web dominant en Java. Si tu connais Symfony, tu seras en terrain familier : injection de dépendances, annotations (attributs en PHP), contrôleurs, services, dépôts. Comparons une petite route d’API :

<?php
use App\Models\Tache;
use Illuminate\Http\Request;

Route::get('/taches/{id}', function (int $id) {
    return Tache::findOrFail($id);
});

Route::post('/taches', function (Request $request) {
    $data = $request->validate(['titre' => 'required|max:150']);
    return response()->json(Tache::create($data), 201);
});

<?php
use App\Models\Tache;
use Illuminate\Http\Request;

Route::get('/taches/{id}', function (int $id) {
    return Tache::findOrFail($id);
});

Route::post('/taches', function (Request $request) {
    $data = $request->validate(['titre' => 'required|max:150']);
    return response()->json(Tache::create($data), 201);
});

@RestController
@RequestMapping("/taches")
public class TacheController {

    private final TacheRepository depot;

    public TacheController(TacheRepository depot) {    // injection par le constructeur
        this.depot = depot;
    }

    @GetMapping("/{id}")
    public Tache lire(@PathVariable long id) {
        return depot.findById(id)
            .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Tache creer(@Valid @RequestBody NouvelleTache demande) {
        return depot.save(new Tache(demande.titre()));
    }
}

record NouvelleTache(@NotBlank @Size(max = 150) String titre) {}

@RestController
@RequestMapping("/taches")
public class TacheController {

    private final TacheRepository depot;

    public TacheController(TacheRepository depot) {    // injection par le constructeur
        this.depot = depot;
    }

    @GetMapping("/{id}")
    public Tache lire(@PathVariable long id) {
        return depot.findById(id)
            .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Tache creer(@Valid @RequestBody NouvelleTache demande) {
        return depot.save(new Tache(demande.titre()));
    }
}

record NouvelleTache(@NotBlank @Size(max = 150) String titre) {}

La structure est plus verbeuse, mais tout est explicite et vérifié à la compilation : le type de l’identifiant, la forme du corps de la requête, les règles de validation. Pour comparer avec une API équivalente en JavaScript, vois notre tutoriel API REST avec Node.js, Express et MySQL.

Installer Java et écrire son premier programme (Java pour développeur PHP)

1. Installe un JDK 25 (la version LTS actuelle), par exemple la distribution gratuite Eclipse Temurin d’Adoptium.
2. Vérifie l’installation dans un terminal : java -version.
3. Choisis un éditeur : IntelliJ IDEA (la référence en Java, édition Community gratuite) ou VS Code avec le pack d’extensions Java.
4. Crée un fichier Bonjour.java et lance-le directement, sans étape de compilation manuelle.

// Lancer avec :  java Bonjour.java
void main() {
    var langages = java.util.List.of("PHP", "Java");
    for (var langage : langages) {
        IO.println("Bonjour depuis " + langage + " !");
    }
}

// Lancer avec :  java Bonjour.java
void main() {
    var langages = java.util.List.of("PHP", "Java");
    for (var langage : langages) {
        IO.println("Bonjour depuis " + langage + " !");
    }
}

Depuis Java 25, plus besoin du fameux public static void main(String[] args) ni d’une classe pour un petit programme : la méthode void main() et la classe IO rendent les premiers pas aussi simples qu’un script PHP. Pour un vrai projet, génère un squelette avec Spring Initializr (Spring Boot) ou mvn archetype:generate.

Feuille de route Java pour développeur PHP : 4 semaines

Java pour développeur PHP : les 8 réflexes à oublier

1. Mettre un $ devant les variables (le compilateur te le rappellera vite).
2. Concaténer avec un point : en Java, c’est +.
3. Comparer des chaînes avec == : utilise .equals().
4. Utiliser un tableau associatif pour tout : choisis List, Map ou Set.
5. Compter sur la conversion automatique : "5" + 1 donne "51", et if ("") ne compile pas.
6. Stocker l’état d’une requête dans un attribut static ou de service : il est partagé entre tous les utilisateurs.
7. Utiliser double pour de l’argent : préfère BigDecimal.
8. Ignorer les avertissements de l’IDE : en Java, ils signalent souvent un vrai bug.

FAQ : Java pour développeur PHP

Conclusion

Passer de PHP à Java, ce n’est pas réapprendre à programmer : c’est changer de réflexes. Retiens l’essentiel de ce guide Java pour développeur PHP : l’application vit en permanence dans la JVM, le compilateur vérifie les types avant l’exécution, chaque usage du tableau PHP a sa collection dédiée, les chaînes se comparent avec equals(), et l’écosystème (Maven, JUnit, Spring Boot) a un équivalent pour chacun de tes outils.

Le meilleur moyen de progresser reste de réécrire en Java un projet que tu as déjà réalisé en PHP, par exemple notre application de planning PHP/MySQL. Tu verras vite que la rigueur de Java devient un confort. Pour approfondir, les tutoriels officiels dev.java sont gratuits et à jour.