☕
JAVA
Guide Complet du Langage de Programmation
Des fondamentaux à la programmation orientée objet avancée,
les collections, les lambdas, le multithreading et bien plus.
Table des matières
1. Introduction à Java
2. Installation et environnement (JDK / JRE / JVM)
3. Syntaxe de base et types de données
4. Opérateurs et structures de contrôle
5. Tableaux et chaînes de caractères
6. Programmation orientée objet
7. Héritage, polymorphisme et interfaces
8. Gestion des exceptions
9. Collections (List, Set, Map)
10. Génériques (Generics)
11. Lambdas et Stream API
12. Multithreading et concurrence
13. Entrées/Sorties (fichiers)
14. Bonnes pratiques et conventions
15. Écosystème (Maven, Gradle, outils)
16. Ressources pour aller plus loin
1. Introduction à Java
Java est un langage de programmation orienté objet créé par James Gosling chez Sun Microsystems, sorti en 1995. Racheté par Oracle en 2010, il
reste aujourd'hui l'un des langages les plus utilisés au monde, notamment pour les applications d'entreprise, le développement Android, les systèmes
bancaires et le backend web.
Pourquoi Java est-il si populaire ?
Caractéristique Description
Portable « Write Once, Run Anywhere » grâce à la JVM (Java Virtual Machine)
Orienté objet Tout (ou presque) est objet : classes, héritage, encapsulation, polymorphisme
Robuste Typage statique fort, gestion des exceptions, pas de pointeurs bruts
Sécurisé Exécution sandboxée dans la JVM, gestion mémoire automatique
Multithread Support natif de la concurrence et des threads
Riche écosystème Spring, Hibernate, Maven, Gradle, des millions de bibliothèques
JVM, JRE et JDK
JVM (Java Virtual Machine) : la machine virtuelle qui exécute le bytecode Java
JRE (Java Runtime Environment) : JVM + bibliothèques standard, nécessaire pour exécuter un programme Java
JDK (Java Development Kit) : JRE + outils de développement (compilateur javac , débogueur, etc.), nécessaire pour développer
À retenir : le code source Java (.java) est compilé en bytecode (.class), qui est ensuite interprété/exécuté par la JVM — c'est ce qui rend Java
portable sur toute plateforme disposant d'une JVM.
2. Installation et environnement
Installer le JDK
Téléchargez une distribution du JDK (Oracle JDK, OpenJDK, Eclipse Temurin, Amazon Corretto...). Vérifiez l'installation :
// Dans un terminal
java -version
javac -version
Premier programme : Hello World
public class HelloWorld {
public static void main(String[] args) {
[Link]("Bonjour, Java !");
}
}
Compilation et exécution :
javac [Link] // génère [Link]
java HelloWorld // exécute le programme
Remarque : le nom du fichier doit correspondre exactement au nom de la classe publique qu'il contient (sensible à la casse).
Environnements de développement (IDE)
IntelliJ IDEA — le plus utilisé en entreprise, excellent auto-complétion
Eclipse — historique, très modulaire
VS Code avec l'extension "Extension Pack for Java"
NetBeans
3. Syntaxe de base et types de données
Types primitifs
Type Taille Plage / Exemple
byte 8 bits -128 à 127
short 16 bits -32 768 à 32 767
int 32 bits -2^31 à 2^31-1 (par défaut pour les entiers)
long 64 bits Suffixe L — ex : 1234567890123L
float 32 bits Suffixe f — précision simple
double 64 bits Précision double (par défaut pour les décimaux)
char 16 bits Un caractère Unicode, ex : 'A'
boolean 1 bit (logique) true ou false
Déclaration de variables
int age = 25;
double prix = 19.99;
char lettre = 'J';
boolean estActif = true;
String nom = "Java"; // String n'est pas un type primitif, c'est une classe
// Depuis Java 10 : inférence de type avec "var"
var compteur = 0; // équivalent à int compteur = 0;
Constantes
final double PI = 3.14159; // ne peut plus être modifié
Conversion de types (casting)
double d = 9.7;
int i = (int) d; // conversion explicite : i = 9 (troncature)
int x = 10;
double y = x; // conversion implicite (élargissement) : y = 10.0
4. Opérateurs et structures de contrôle
Opérateurs
Catégorie Opérateurs
Arithmétiques + - * / % ++ --
Affectation = += -= *= /= %=
Comparaison == != > < >= <=
Logiques && || !
Ternaire condition ? valeurSiVrai : valeurSiFaux
Conditions
if (age >= 18) {
[Link]("Majeur");
} else if (age >= 13) {
[Link]("Adolescent");
} else {
[Link]("Enfant");
}
// switch classique
switch (jour) {
case 1: [Link]("Lundi"); break;
case 2: [Link]("Mardi"); break;
default: [Link]("Autre jour");
}
// switch expression (Java 14+)
String resultat = switch (jour) {
case 1 -> "Lundi";
case 2 -> "Mardi";
default -> "Autre";
};
Boucles
// for classique
for (int i = 0; i < 5; i++) {
[Link](i);
}
// for-each
for (String fruit : fruits) {
[Link](fruit);
}
// while
while (compteur < 10) {
compteur++;
}
// do-while (exécuté au moins une fois)
do {
compteur--;
} while (compteur > 0);
5. Tableaux et chaînes de caractères
Tableaux
int[] nombres = {1, 2, 3, 4, 5};
String[] noms = new String[3];
noms[0] = "Alice";
// Tableau à deux dimensions
int[][] matrice = {{1,2}, {3,4}};
// Parcours
for (int n : nombres) {
[Link](n);
}
La classe String
Les String sont immuables : toute opération renvoie une nouvelle chaîne plutôt que de modifier l'originale.
String s = "Bonjour Java";
[Link](); // 12
[Link](); // "BONJOUR JAVA"
[Link](0, 7); // "Bonjour"
[Link]("Java", "Monde"); // "Bonjour Monde"
[Link](" "); // ["Bonjour", "Java"]
[Link]("Java"); // true
[Link]("Bonjour Java"); // true (comparer avec equals(), jamais ==)
Attention : utilisez toujours .equals() pour comparer des chaînes de caractères, jamais == (qui compare les références mémoire).
StringBuilder
Pour concaténer efficacement de nombreuses chaînes (évite de recréer un objet String à chaque étape) :
StringBuilder sb = new StringBuilder();
[Link]("Bonjour").append(" ").append("Java");
[Link]([Link]());
6. Programmation orientée objet
Classes et objets
public class Voiture {
// Attributs (état)
private String marque;
private int vitesse;
// Constructeur
public Voiture(String marque) {
[Link] = marque;
[Link] = 0;
}
// Méthodes (comportement)
public void accelerer(int valeur) {
vitesse += valeur;
}
public String getMarque() {
return marque;
}
}
// Utilisation
Voiture maVoiture = new Voiture("Toyota");
[Link](50);
Les 4 piliers de la POO
Pilier Description
Encapsulation Cacher les attributs (private) et exposer des accesseurs (getters/setters)
Héritage Une classe hérite des attributs/méthodes d'une autre via extends
Polymorphisme Une méthode peut se comporter différemment selon l'objet (redéfinition/surcharge)
Abstraction Modéliser des concepts génériques avec des classes abstraites/interfaces
Modificateurs d'accès
Modificateur Visibilité
private Uniquement dans la classe
(par défaut) Dans le même package
protected Package + sous-classes
public Partout
Getters, setters et constructeurs
public class Personne {
private String nom;
private int age;
public Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
}
public String getNom() { return nom; }
public void setNom(String nom) { [Link] = nom; }
// Redéfinition de toString()
@Override
public String toString() {
return nom + " (" + age + " ans)";
}
}
7. Héritage, polymorphisme et interfaces
Héritage
public class Animal {
protected String nom;
public void parler() {
[Link]("...");
}
}
public class Chien extends Animal {
@Override
public void parler() {
[Link]("Wouf !");
}
}
Classes abstraites
public abstract class Forme {
public abstract double aire(); // pas de corps, doit être implémentée
public void afficher() {
[Link]("Aire : " + aire());
}
}
public class Cercle extends Forme {
private double rayon;
public double aire() { return [Link] * rayon * rayon; }
}
Interfaces
public interface Volant {
void voler(); // implicitement public abstract
// Méthode par défaut (Java 8+)
default void atterrir() {
[Link]("Atterrissage...");
}
}
public class Oiseau implements Volant {
public void voler() { [Link]("L'oiseau vole"); }
}
Interface vs classe abstraite : une classe ne peut hériter que d'une seule classe (abstraite ou non) mais peut implémenter plusieurs
interfaces. Les interfaces définissent un contrat, les classes abstraites peuvent partager du code commun.
Polymorphisme
Animal monAnimal = new Chien(); // référence de type parent
[Link](); // affiche "Wouf !" -> liaison dynamique
// Surcharge (overloading) : même nom, paramètres différents
public int additionner(int a, int b) { return a + b; }
public double additionner(double a, double b) { return a + b; }
Classes utiles : record, enum
// record (Java 16+) : classe immuable concise pour transporter des données
public record Point(int x, int y) {}
Point p = new Point(3, 4);
p.x(); // 3
// enum : ensemble fixe de constantes
public enum Jour { LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE }
8. Gestion des exceptions
Hiérarchie
Throwable est la racine, avec deux branches : Error (erreurs graves de la JVM, non gérées habituellement) et Exception , elle-même divisée en
exceptions vérifiées (checked, doivent être déclarées ou capturées) et non vérifiées (unchecked, sous-classes de RuntimeException ).
try / catch / finally
try {
int resultat = 10 / 0;
} catch (ArithmeticException e) {
[Link]("Erreur : " + [Link]());
} finally {
[Link]("Toujours exécuté");
}
try-with-resources
Ferme automatiquement les ressources (fichiers, connexions) qui implémentent AutoCloseable :
try (BufferedReader br = new BufferedReader(new FileReader("[Link]"))) {
[Link]([Link]());
} catch (IOException e) {
[Link]();
}
Créer ses propres exceptions
public class SoldeInsuffisantException extends Exception {
public SoldeInsuffisantException(String message) {
super(message);
}
}
// Utilisation
public void retirer(double montant) throws SoldeInsuffisantException {
if (montant > solde) {
throw new SoldeInsuffisantException("Solde insuffisant");
}
}
Bonne pratique : ne jamais laisser un bloc catch vide — cela masque les erreurs et complique le débogage.
9. Collections (List, Set, Map)
Vue d'ensemble
Interface Implémentations courantes Caractéristiques
List ArrayList, LinkedList Ordonnée, doublons autorisés, accès par index
Set HashSet, TreeSet, LinkedHashSet Pas de doublons
Map HashMap, TreeMap, LinkedHashMap Paires clé-valeur, clés uniques
Queue ArrayDeque, PriorityQueue FIFO / priorité
List
List<String> fruits = new ArrayList<>();
[Link]("Pomme");
[Link]("Banane");
[Link](0); // "Pomme"
[Link]("Banane");
[Link](); // 1
[Link]("Pomme"); // true
Set
Set<Integer> nombres = new HashSet<>();
[Link](1);
[Link](1); // ignoré, déjà présent
[Link]([Link]()); // 1
Map
Map<String, Integer> ages = new HashMap<>();
[Link]("Alice", 30);
[Link]("Bob", 25);
[Link]("Alice"); // 30
[Link]("Eve", 0); // 0 si absente
for ([Link]<String, Integer> entree : [Link]()) {
[Link]([Link]() + " -> " + [Link]());
}
Trier une collection
List<Integer> liste = new ArrayList<>([Link](5,2,8,1));
[Link](liste); // tri naturel croissant
[Link]([Link]()); // tri décroissant
10. Génériques (Generics)
Les génériques permettent d'écrire du code réutilisable, indépendant du type, tout en gardant la sécurité du typage à la compilation.
// Classe générique
public class Boite<T> {
private T contenu;
public void setContenu(T contenu) { [Link] = contenu; }
public T getContenu() { return contenu; }
}
Boite<String> boiteTexte = new Boite<>();
[Link]("Bonjour");
// Méthode générique
public static <T> T premierElement(List<T> liste) {
return [Link](0);
}
// Bornes (wildcards)
public static void afficherTous(List<? extends Number> liste) {
for (Number n : liste) [Link](n);
}
11. Lambdas et Stream API
Expressions lambda (Java 8+)
// Syntaxe : (paramètres) -> expression
Runnable r = () -> [Link]("Exécution");
Comparator<String> parLongueur = (a, b) -> [Link]() - [Link]();
// Interface fonctionnelle personnalisée
interface Operation { int appliquer(int a, int b); }
Operation addition = (a, b) -> a + b;
[Link]([Link](3, 4)); // 7
Interfaces fonctionnelles courantes
Interface Signature Usage
Function<T,R> R apply(T t) Transformer une valeur
Predicate<T> boolean test(T t) Tester une condition
Consumer<T> void accept(T t) Consommer une valeur (sans retour)
Supplier<T> T get() Fournir une valeur
Stream API
Les streams permettent de traiter des collections de façon déclarative (filtrage, transformation, agrégation).
List<String> noms = [Link]("Alice", "Bob", "Charlie", "Anna");
List<String> resultat = [Link]()
.filter(n -> [Link]("A"))
.map(String::toUpperCase)
.sorted()
.collect([Link]());
// ["ALICE", "ANNA"]
// Opérations d'agrégation
long total = [Link]().count();
Optional<String> premier = [Link]().findFirst();
int sommeLongueurs = [Link]().mapToInt(String::length).sum();
Astuce : les streams sont paresseux (lazy) — rien ne s'exécute tant qu'une opération terminale ( collect , forEach , sum ...) n'est pas appelée.
12. Multithreading et concurrence
Créer un thread
// Via la classe Thread
class MonThread extends Thread {
public void run() {
[Link]("Thread en cours d'exécution");
}
}
new MonThread().start();
// Via Runnable (préférable)
Runnable tache = () -> [Link]("Tâche exécutée");
new Thread(tache).start();
ExecutorService (recommandé)
ExecutorService executor = [Link](4);
[Link](() -> [Link]("Tâche 1"));
[Link](() -> [Link]("Tâche 2"));
[Link]();
Synchronisation
public synchronized void incrementer() {
compteur++; // accès exclusif à un seul thread à la fois
}
// Ou avec un bloc synchronized
synchronized (this) {
compteur++;
}
Attention aux deadlocks : évitez de verrouiller plusieurs ressources dans des ordres différents entre threads.
13. Entrées/Sorties (fichiers)
Lire un fichier
try (BufferedReader reader = new BufferedReader(new FileReader("[Link]"))) {
String ligne;
while ((ligne = [Link]()) != null) {
[Link](ligne);
}
} catch (IOException e) {
[Link]();
}
Écrire dans un fichier
try (BufferedWriter writer = new BufferedWriter(new FileWriter("[Link]"))) {
[Link]("Bonjour Java !");
} catch (IOException e) {
[Link]();
}
API NIO (moderne)
Path chemin = [Link]("[Link]");
List<String> lignes = [Link](chemin);
[Link]([Link]("[Link]"), "Contenu");
14. Bonnes pratiques et conventions
Conventions de nommage
Élément Convention Exemple
Classes PascalCase MaClasse
Méthodes / variables camelCase maVariable
Constantes MAJUSCULES_SNAKE VITESSE_MAX
Packages minuscules [Link]
Principes recommandés
Privilégier la composition à l'héritage quand c'est possible
Rendre les classes immuables quand c'est pertinent (attributs final )
Toujours redéfinir equals() et hashCode() ensemble
Programmer contre des interfaces, pas des implémentations ( List<String> l = new ArrayList<>(); )
Utiliser Optional<T> pour éviter les NullPointerException
Documenter le code public avec des Javadoc ( /** ... */ )
Suivre les principes SOLID pour un code maintenable
Javadoc
/**
* Calcule la somme de deux entiers.
* @param a premier nombre
* @param b second nombre
* @return la somme de a et b
*/
public static int somme(int a, int b) {
return a + b;
}
15. Écosystème (Maven, Gradle, outils)
Maven
Outil de gestion de projet et de dépendances, basé sur un fichier [Link] :
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.2.0</version>
</dependency>
</dependencies>
mvn clean install # compile, teste, packages
mvn test # exécute les tests
Gradle
Alternative plus rapide et flexible à Maven, basée sur un DSL Groovy/Kotlin ( [Link] ).
Frameworks incontournables
Framework Usage
Spring / Spring Boot Applications web, microservices, injection de dépendances
Hibernate / JPA Mapping objet-relationnel (ORM) pour bases de données
JUnit Tests unitaires
Maven / Gradle Build et gestion de dépendances
Apache Kafka Traitement de flux de données
16. Ressources pour aller plus loin
Documentation officielle Oracle — [Link]/en/java
Baeldung — tutoriels approfondis sur Java et Spring
Effective Java de Joshua Bloch — référence incontournable sur les bonnes pratiques
Java: The Complete Reference de Herbert Schildt
Pratiquer sur LeetCode, HackerRank ou Codewars
Pour progresser : commencez par maîtriser la syntaxe et la POO, puis attaquez les collections et les streams, avant de vous lancer dans un
framework comme Spring Boot pour construire de vraies applications.
— Fin du guide — Bon apprentissage avec Java ! ☕ —