Core Java: Guide Complet pour Maîtriser les Fondamentaux

Java est l’un des langages de programmation les plus utilisés au monde, particulièrement apprécié pour sa portabilité, sa robustesse et son écosystème riche. Ce guide vous présente les concepts fondamentaux de Core Java, des bases jusqu’aux fonctionnalités plus avancées.

Introduction à Java

Java a été créé par James Gosling chez Sun Microsystems (maintenant Oracle) et lancé en 1995. Sa philosophie “Write Once, Run Anywhere” (WORA) a révolutionné le développement logiciel.

Caractéristiques principales

• Orienté objet: Tout en Java est un objet, à l’exception des types primitifs
• Indépendant de la plateforme: Grâce à la JVM (Java Virtual Machine)
• Robuste: Gestion d’erreurs solide, vérification des types à la compilation
• Sécurisé: Exécution dans un environnement contrôlé (sandbox)
• Multi-threading: Support intégré pour la programmation concurrente
• Haute performance: Compilateur JIT (Just-In-Time) optimisant l’exécution

Installation et configuration

Installer le JDK (Java Development Kit)

# Sur Ubuntu/Debian
sudo apt update
sudo apt install openjdk-17-jdk

# Sur macOS avec Homebrew
brew install openjdk@17

# Sur Windows
# Télécharger depuis https://www.oracle.com/java/technologies/downloads/

Configurer les variables d’environnement

# Sur Linux/macOS
export JAVA_HOME=/path/to/jdk
export PATH=$PATH:$JAVA_HOME/bin

# Sur Windows
# Définir JAVA_HOME et ajouter %JAVA_HOME%\bin au PATH

Premiers pas avec Java

Structure de base d’un programme Java

// Fichier: HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Compiler et exécuter

# Compiler
javac HelloWorld.java

# Exécuter
java HelloWorld

Types de données et variables

Types primitifs

// Types numériques entiers
byte b = 127;         // 8 bits, -128 à 127
short s = 32767;      // 16 bits, -32,768 à 32,767
int i = 2147483647;   // 32 bits, -2,147,483,648 à 2,147,483,647
long l = 9223372036854775807L; // 64 bits, très grand intervalle

// Types numériques à virgule flottante
float f = 3.14f;      // 32 bits
double d = 3.14159;   // 64 bits

// Autres types primitifs
char c = 'A';         // 16 bits, caractère Unicode
boolean bool = true;  // true ou false

Variables et constantes

// Déclaration de variable
int nombre;
nombre = 42;

// Déclaration et initialisation
String message = "Bonjour";

// Constantes (final)
final double PI = 3.14159;

Opérateurs

Opérateurs arithmétiques

int a = 10, b = 3;
int somme = a + b;       // 13
int difference = a - b;  // 7
int produit = a * b;     // 30
int quotient = a / b;    // 3 (division entière)
int reste = a % b;       // 1 (modulo)

// Incrémentation et décrémentation
a++;  // a = a + 1
b--;  // b = b - 1

Opérateurs de comparaison

boolean egal = (a == b);        // false
boolean different = (a != b);   // true
boolean superieur = (a > b);    // true
boolean inferieur = (a < b);    // false
boolean supOuEgal = (a >= b);   // true
boolean infOuEgal = (a <= b);   // false

Opérateurs logiques

boolean x = true, y = false;
boolean et = x && y;    // false (AND logique)
boolean ou = x || y;    // true (OR logique)
boolean non = !x;       // false (NOT logique)

Structures de contrôle

Conditions

// If-else
int age = 18;
if (age < 18) {
    System.out.println("Mineur");
} else if (age == 18) {
    System.out.println("Tout juste majeur");
} else {
    System.out.println("Majeur");
}

// Switch
int jour = 3;
switch (jour) {
    case 1:
        System.out.println("Lundi");
        break;
    case 2:
        System.out.println("Mardi");
        break;
    case 3:
        System.out.println("Mercredi");
        break;
    // ...
    default:
        System.out.println("Jour inconnu");
}

// Expression ternaire
String statut = (age >= 18) ? "Majeur" : "Mineur";

Boucles

// Boucle for
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

// Boucle while
int compteur = 0;
while (compteur < 5) {
    System.out.println(compteur);
    compteur++;
}

// Boucle do-while
int j = 0;
do {
    System.out.println(j);
    j++;
} while (j < 5);

// Boucle for-each (pour les collections)
int[] nombres = {1, 2, 3, 4, 5};
for (int nombre : nombres) {
    System.out.println(nombre);
}

Tableaux et Collections

Tableaux

// Déclaration et initialisation d'un tableau
int[] nombres = new int[5];
nombres[0] = 10;
nombres[1] = 20;

// Initialisation avec des valeurs
int[] valeurs = {10, 20, 30, 40, 50};

// Tableau multidimensionnel
int[][] matrice = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Parcourir un tableau
for (int i = 0; i < nombres.length; i++) {
    System.out.println(nombres[i]);
}

Collections Framework

import java.util.*;

// Liste
List<String> liste = new ArrayList<>();
liste.add("Pomme");
liste.add("Banane");
liste.add("Orange");
System.out.println(liste.get(1));  // Banane
liste.remove("Pomme");

// Ensemble (éléments uniques)
Set<Integer> ensemble = new HashSet<>();
ensemble.add(1);
ensemble.add(2);
ensemble.add(1);  // Ignoré car déjà présent
System.out.println(ensemble.size());  // 2

// Map (clé-valeur)
Map<String, Integer> map = new HashMap<>();
map.put("Pierre", 30);
map.put("Marie", 25);
System.out.println(map.get("Marie"));  // 25

Programmation Orientée Objet (POO)

Classes et objets

// Définition d'une classe
public class Personne {
    // Attributs (champs)
    private String nom;
    private int age;
    
    // Constructeur
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
    
    // Méthodes
    public void sePresenter() {
        System.out.println("Je m'appelle " + nom + " et j'ai " + age + " ans.");
    }
    
    // Getters et Setters
    public String getNom() {
        return nom;
    }
    
    public void setNom(String nom) {
        this.nom = nom;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

// Utilisation de la classe
Personne personne = new Personne("Alice", 30);
personne.sePresenter();
personne.setAge(31);
System.out.println(personne.getAge());  // 31

Héritage

// Classe parente
public class Animal {
    protected String nom;
    
    public Animal(String nom) {
        this.nom = nom;
    }
    
    public void manger() {
        System.out.println(nom + " mange.");
    }
}

// Classe enfant
public class Chien extends Animal {
    private String race;
    
    public Chien(String nom, String race) {
        super(nom);  // Appel du constructeur parent
        this.race = race;
    }
    
    public void aboyer() {
        System.out.println(nom + " aboie.");
    }
    
    // Surcharge de méthode
    @Override
    public void manger() {
        System.out.println(nom + " le chien mange des croquettes.");
    }
}

// Utilisation
Chien rex = new Chien("Rex", "Berger Allemand");
rex.manger();  // "Rex le chien mange des croquettes."
rex.aboyer();  // "Rex aboie."

Polymorphisme

Animal animal1 = new Animal("Truc");
Animal animal2 = new Chien("Médor", "Labrador");  // Polymorphisme

animal1.manger();  // "Truc mange."
animal2.manger();  // "Médor le chien mange des croquettes."

// animal2.aboyer();  // Erreur de compilation, car animal2 est de type Animal
((Chien) animal2).aboyer();  // OK après cast

Interfaces

// Définition d'une interface
public interface Nageur {
    void nager();
}

// Implémentation d'une interface
public class Poisson extends Animal implements Nageur {
    public Poisson(String nom) {
        super(nom);
    }
    
    @Override
    public void nager() {
        System.out.println(nom + " nage rapidement.");
    }
}

// Multiple implémentation
public class Canard extends Animal implements Nageur {
    public Canard(String nom) {
        super(nom);
    }
    
    @Override
    public void nager() {
        System.out.println(nom + " nage lentement.");
    }
}

// Utilisation
Nageur nageur1 = new Poisson("Nemo");
Nageur nageur2 = new Canard("Donald");
nageur1.nager();  // "Nemo nage rapidement."
nageur2.nager();  // "Donald nage lentement."

Classes abstraites

// Classe abstraite
public abstract class Vehicule {
    protected String marque;
    
    public Vehicule(String marque) {
        this.marque = marque;
    }
    
    // Méthode concrète
    public void demarrer() {
        System.out.println("Le véhicule démarre.");
    }
    
    // Méthode abstraite (à implémenter par les sous-classes)
    public abstract void accelerer();
}

// Implémentation d'une classe abstraite
public class Voiture extends Vehicule {
    public Voiture(String marque) {
        super(marque);
    }
    
    @Override
    public void accelerer() {
        System.out.println("La voiture " + marque + " accélère.");
    }
}

Gestion des exceptions

Try-catch-finally

try {
    // Code susceptible de générer une exception
    int resultat = 10 / 0;  // Division par zéro
} catch (ArithmeticException e) {
    // Gestion de l'exception
    System.out.println("Erreur: Division par zéro");
    e.printStackTrace();
} finally {
    // Code exécuté dans tous les cas
    System.out.println("Fin du traitement");
}

Exceptions personnalisées

// Définition d'une exception personnalisée
public class AgeInvalideException extends Exception {
    public AgeInvalideException(String message) {
        super(message);
    }
}

// Utilisation
public class Utilisateur {
    private String nom;
    private int age;
    
    public void setAge(int age) throws AgeInvalideException {
        if (age < 0 || age > 150) {
            throw new AgeInvalideException("L'âge doit être compris entre 0 et 150");
        }
        this.age = age;
    }
}

// Gestion de l'exception
Utilisateur utilisateur = new Utilisateur();
try {
    utilisateur.setAge(200);
} catch (AgeInvalideException e) {
    System.out.println("Erreur: " + e.getMessage());
}

Entrées/Sorties (I/O)

Lecture de fichiers

import java.io.*;

// try-with-resources pour fermeture automatique
try (BufferedReader reader = new BufferedReader(new FileReader("fichier.txt"))) {
    String ligne;
    while ((ligne = reader.readLine()) != null) {
        System.out.println(ligne);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Écriture de fichiers

try (BufferedWriter writer = new BufferedWriter(new FileWriter("sortie.txt"))) {
    writer.write("Ligne 1");
    writer.newLine();
    writer.write("Ligne 2");
} catch (IOException e) {
    e.printStackTrace();
}

Flux d’E/S

// Entrée console
try (Scanner scanner = new Scanner(System.in)) {
    System.out.print("Entrez votre nom: ");
    String nom = scanner.nextLine();
    System.out.println("Bonjour, " + nom + "!");
}

// Sortie formatée
System.out.printf("Température: %.1f°C%n", 22.5);

Généricité

// Classe générique
public class Boite<T> {
    private T contenu;
    
    public void mettre(T contenu) {
        this.contenu = contenu;
    }
    
    public T prendre() {
        return contenu;
    }
}

// Utilisation
Boite<String> boiteTexte = new Boite<>();
boiteTexte.mettre("Hello");
String texte = boiteTexte.prendre();

Boite<Integer> boiteNombre = new Boite<>();
boiteNombre.mettre(42);
int nombre = boiteNombre.prendre();

Méthodes génériques

public <T> void afficherTableau(T[] tableau) {
    for (T element : tableau) {
        System.out.println(element);
    }
}

// Utilisation
String[] mots = {"Bonjour", "le", "monde"};
Integer[] nombres = {1, 2, 3, 4, 5};

afficherTableau(mots);
afficherTableau(nombres);

Lambda et Streams (Java 8+)

Expressions lambda

// Interface fonctionnelle
interface Calculateur {
    int calculer(int a, int b);
}

// Approche traditionnelle
Calculateur addition = new Calculateur() {
    @Override
    public int calculer(int a, int b) {
        return a + b;
    }
};

// Avec lambda
Calculateur additionLambda = (a, b) -> a + b;
System.out.println(additionLambda.calculer(5, 3));  // 8

// Autres exemples
Runnable tache = () -> System.out.println("Tâche exécutée");
Comparator<String> comparateur = (s1, s2) -> s1.length() - s2.length();

API Stream

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<String> noms = Arrays.asList("Jean", "Marie", "Pierre", "Sophie");

// Filtrage
List<String> nomsLongs = noms.stream()
    .filter(nom -> nom.length() > 4)
    .collect(Collectors.toList());  // [Marie, Pierre, Sophie]

// Mapping
List<Integer> longueurs = noms.stream()
    .map(String::length)
    .collect(Collectors.toList());  // [4, 5, 6, 6]

// Réduction
int somme = noms.stream()
    .mapToInt(String::length)
    .sum();  // 21

// Autres opérations
boolean tousLongs = noms.stream().allMatch(nom -> nom.length() > 3);  // true
String concatenation = noms.stream().collect(Collectors.joining(", "));  // "Jean, Marie, Pierre, Sophie"

Multithreading et concurrence

Création de threads

// Méthode 1: Étendre Thread
class MonThread extends Thread {
    @Override
    public void run() {
        System.out.println("MonThread s'exécute");
    }
}

// Méthode 2: Implémenter Runnable
class MaTache implements Runnable {
    @Override
    public void run() {
        System.out.println("MaTache s'exécute");
    }
}

// Utilisation
Thread thread1 = new MonThread();
thread1.start();

Thread thread2 = new Thread(new MaTache());
thread2.start();

// Lambda avec Runnable
Thread thread3 = new Thread(() -> {
    System.out.println("Tâche lambda s'exécute");
});
thread3.start();

Synchronisation

public class Compteur {
    private int valeur = 0;
    
    // Méthode synchronisée
    public synchronized void incrementer() {
        valeur++;
    }
    
    // Bloc synchronisé
    public void incrementerBloc() {
        synchronized(this) {
            valeur++;
        }
    }
    
    public int getValeur() {
        return valeur;
    }
}

ExecutorService

import java.util.concurrent.*;

// Création d'un pool de threads
ExecutorService executor = Executors.newFixedThreadPool(5);

// Soumettre des tâches
executor.submit(() -> {
    System.out.println("Tâche exécutée par " + Thread.currentThread().getName());
});

// Attendre la terminaison de toutes les tâches
executor.shutdown();
executor.awaitTermination(5, TimeUnit.SECONDS);

Conclusion

Java est un langage robuste et polyvalent qui offre une large gamme de fonctionnalités pour développer des applications de qualité. En maîtrisant ces concepts fondamentaux, vous pourrez:

• Créer des applications complètes et performantes
• Comprendre et utiliser l’écosystème Java (Spring, Hibernate, etc.)
• Développer des solutions d’entreprise fiables et maintenables
• Mettre en œuvre des architectures logicielles modernes

Pour aller plus loin, explorez les frameworks Java populaires comme Spring Boot, la programmation réactive avec Project Reactor ou RxJava, et les API plus récentes comme les modules (Java 9+) et les records (Java 16+).