Menu

Formation Java

Apprenez Java, l'un des langages de programmation les plus populaires au monde

Faire un don

Créez un compte gratuitement

Suivez votre progression, sauvegardez vos avancées et obtenez des certificats de complétion. Rejoignez des milliers d'apprenants qui développent leurs compétences avec nous !

Suivi de progression détaillé
Certificats téléchargeables
Badges et accomplissements

Introduction à Java

Java est un langage de programmation orienté objet, compilé et multiplateforme, créé par James Gosling chez Sun Microsystems (maintenant Oracle) et publié en 1995. Java est l'un des langages les plus utilisés au monde, particulièrement dans le développement d'applications d'entreprise, Android, et systèmes backend.

☕ Qu'est-ce que Java ?

Java est un langage de programmation compilé et orienté objet. Le code Java est compilé en bytecode qui s'exécute sur la Java Virtual Machine (JVM), ce qui permet à Java d'être "écrit une fois, exécuté partout" (WORA - Write Once, Run Anywhere). Java est fortement typé et suit le paradigme orienté objet.

💡 Pourquoi Java est si populaire ?

  1. Multiplateforme - "Écrit une fois, exécuté partout" grâce à la JVM, fonctionne sur Windows, Linux, macOS
  2. Très utilisé en entreprise - Langage de choix pour les applications d'entreprise, systèmes backend, microservices
  3. Développement Android - Langage principal pour développer des applications Android
  4. Robuste et sécurisé - Gestion automatique de la mémoire, système de sécurité intégré, typage fort
  5. Vaste écosystème - Spring, Hibernate, Maven, Gradle, et des milliers de bibliothèques
  6. Communauté massive - Des millions de développeurs, documentation complète, support actif

🚀 Pourquoi apprendre Java ?

Java est un excellent choix pour apprendre la programmation orientée objet et développer des applications professionnelles :

  • ✅ Très demandé - L'un des langages les plus recherchés sur le marché du travail. Utilisé par Google, Amazon, Netflix, LinkedIn, Uber
  • ✅ Développement Android - Langage principal pour créer des applications mobiles Android
  • ✅ Applications d'entreprise - Standard de l'industrie pour les systèmes backend, microservices, applications bancaires
  • ✅ Gratuit et Open-Source - JDK open-source, multiplateforme, communauté active
  • ✅ Écosystème riche - Spring Framework, Hibernate, Maven, Gradle, et des milliers de bibliothèques
  • ✅ Grande communauté - Support et ressources abondantes, forums actifs, documentation complète
  • ✅ Carrière stable - Beaucoup d'opportunités d'emploi avec de bons salaires

📋 Prérequis pour apprendre Java

Pour apprendre Java efficacement, il est recommandé d'avoir :

  • ✅ Informatique de base - Savoir utiliser un ordinateur, créer et éditer des fichiers
  • ✅ Logique de programmation - Comprendre les concepts de base (variables, conditions, boucles) est recommandé
  • ✅ Concepts OOP - Comprendre les classes, objets, héritage est utile mais vous les apprendrez avec Java

💡 Note importante : Pour commencer avec Java, vous devez installer le JDK (Java Development Kit) depuis oracle.com ou utiliser OpenJDK. Vous pouvez utiliser un IDE comme IntelliJ IDEA, Eclipse, ou VS Code avec l'extension Java. Pour tester rapidement, vous pouvez utiliser des environnements en ligne comme Repl.it ou OnlineGDB.

🎯 Cas d'usage de Java

Java est utilisé dans de nombreux domaines :

  • Développement Android - Langage principal pour créer des applications mobiles Android
  • Applications web - Spring Boot, Java EE pour créer des applications web et API REST
  • Applications d'entreprise - Systèmes backend, microservices, applications bancaires et financières
  • Cloud Computing - Développement d'applications cloud avec Spring Cloud, AWS SDK
  • Développement de jeux - LibGDX, jMonkeyEngine pour créer des jeux vidéo
  • Outils et frameworks - Maven, Gradle, Jenkins, Elasticsearch sont écrits en Java
  • Big Data - Hadoop, Spark utilisent Java pour le traitement de grandes quantités de données
  • Systèmes financiers - Trading, systèmes bancaires, applications financières

📝 Syntaxe de base

La syntaxe Java est basée sur C/C++ mais simplifiée. Java utilise des accolades {} pour définir les blocs de code et est un langage fortement typé, ce qui signifie que vous devez déclarer le type de chaque variable.

// Premier programme Java
public class BonjourMonde {
    public static void main(String[] args) {
        System.out.println("Bonjour, monde !");
        
        // Variables
        String nom = "NiangProgrammeur";
        int age = 25;
        
        // Affichage formaté
        System.out.println("Je m'appelle " + nom + " et j'ai " + age + " ans");
        
        // Opérations simples
        int resultat = 10 + 5;
        System.out.println("10 + 5 = " + resultat);
    }
}

💡 Points importants sur la syntaxe Java :

  • Java utilise des accolades {} pour définir les blocs de code (classes, méthodes, conditions, boucles)
  • Les commentaires utilisent // pour une ligne, ou /* */ pour plusieurs lignes
  • Point-virgule obligatoire ; à la fin de chaque instruction
  • Java est sensible à la casse - MaClasse est différent de maclasse
  • Chaque fichier doit contenir une classe publique avec le même nom que le fichier
  • Méthode main - Point d'entrée de tout programme Java : public static void main(String[] args)
  • Conventions de nommage - Classes en PascalCase, méthodes/variables en camelCase, constantes en UPPER_CASE

🔍 Exemple détaillé de syntaxe

Voici un exemple complet montrant plusieurs aspects de la syntaxe Java :

// Définition d'une classe
public class Calculatrice {
    // Méthode pour calculer la moyenne
    public static double calculerMoyenne(int[] nombres) {
        if (nombres.length == 0) {
            return 0;
        }
        int somme = 0;
        for (int nombre : nombres) {
            somme += nombre;
        }
        double moyenne = (double) somme / nombres.length;
        return moyenne;
    }
    
    // Méthode principale
    public static void main(String[] args) {
        int[] notes = {15, 18, 12, 20, 16};
        double moyenne = calculerMoyenne(notes);
        System.out.println("La moyenne est : " + moyenne);
    }
}

🔤 Variables

En Java, les variables doivent être déclarées avec un type avant d'être utilisées. Java est un langage à typage statique, ce qui signifie que le type d'une variable est déterminé au moment de la compilation et ne peut pas changer.

// Déclaration de variables
String nom = "Java";           // String (chaîne de caractères)
int age = 30;                  // int (entier)
double prix = 19.99;           // double (nombre décimal)
boolean estActif = true;       // boolean (booléen)
Object valeurNulle = null;     // null (valeur nulle)

// Affichage
System.out.println(nom);
System.out.println(age);
System.out.println(prix);
System.out.println(estActif);
System.out.println(valeurNulle);

// Déclaration puis assignation
int nombre;
nombre = 10;
System.out.println(nombre);

// Variables finales (constantes)
final double PI = 3.14159;     // Ne peut pas être modifiée
final String NOM_APPLICATION = "MonApp";

// Noms de variables valides
String nomUtilisateur = "Bassirou";
int ageUtilisateur = 25;
String _prive = "variable privée";  // Possible mais non recommandé

📌 Règles pour les noms de variables :

  • Doivent commencer par une lettre, underscore _, ou dollar $
  • Peuvent contenir des lettres, chiffres, underscores et dollars
  • Ne peuvent pas contenir d'espaces (utilisez camelCase à la place)
  • Sont sensibles à la casse (age ≠ Age)
  • Ne peuvent pas être des mots-clés Java (if, for, class, etc.)
  • Convention : utilisez camelCase pour les variables (ex: nomUtilisateur)
  • Pour les constantes : utilisez UPPER_CASE avec underscores (ex: MAX_SIZE)

📊 Types de données

Java a deux catégories de types de données : types primitifs et types objets (références). Voici les principaux :

// Types primitifs (8 types)
byte petitNombre = 127;           // 8 bits (-128 à 127)
short nombreCourt = 32767;        // 16 bits
int nombre = 42;                  // 32 bits (le plus utilisé)
long grandNombre = 1234567890L;   // 64 bits (notez le L)
float decimal = 3.14f;            // 32 bits (notez le f)
double decimalPrecis = 3.14159;    // 64 bits (le plus utilisé)
char caractere = 'A';              // 16 bits (un seul caractère)
boolean estVrai = true;            // true ou false

// Types objets (références)
String texte = "Hello";            // String (chaîne de caractères)
Integer nombreObjet = 42;          // Wrapper pour int
Double decimalObjet = 3.14;        // Wrapper pour double

// Collections
int[] tableau = {1, 2, 3, 4, 5};  // Tableau
ArrayList<Integer> liste = new ArrayList<>();  // Liste dynamique
HashMap<String, Integer> map = new HashMap<>();  // Map (clé-valeur)

// Vérifier le type
System.out.println(texte.getClass().getName());  // java.lang.String
System.out.println(((Object) nombre).getClass().getName());  // java.lang.Integer (auto-boxing)

// Conversion de types
String ageStr = String.valueOf(25);  // Convertir en String
int ageInt = Integer.parseInt("25");  // Convertir en int
double prixDouble = Double.parseDouble("19.99");  // Convertir en double

📚 Types de données Java :

  • Types primitifs - byte, short, int, long, float, double, char, boolean
  • String - Chaînes de caractères (classe spéciale, immuable)
  • Tableaux - Collections de taille fixe (int[], String[], etc.)
  • Collections - ArrayList, HashMap, HashSet, etc. (du package java.util)

🔢 Opérateurs

Java supporte les opérateurs arithmétiques, de comparaison, logiques, d'assignation et d'instance :

// Opérateurs arithmétiques
int a = 10;
int b = 3;

System.out.println(a + b);    // Addition: 13
System.out.println(a - b);    // Soustraction: 7
System.out.println(a * b);    // Multiplication: 30
System.out.println(a / b);    // Division entière: 3
System.out.println((double)a / b);  // Division: 3.333...
System.out.println(a % b);    // Modulo (reste): 1
System.out.println(Math.pow(a, b));  // Puissance: 1000.0

// Opérateurs de comparaison
System.out.println(a > b);    // true (supérieur à)
System.out.println(a < b);    // false (inférieur à)
System.out.println(a >= b);   // true (supérieur ou égal)
System.out.println(a <= b);   // false (inférieur ou égal)
System.out.println(a == b);   // false (égalité)
System.out.println(a != b);   // true (différent)

// Opérateurs logiques
boolean x = true;
boolean y = false;
System.out.println(x && y);  // false (ET logique)
System.out.println(x || y);   // true (OU logique)
System.out.println(!x);       // false (NON logique)

// Opérateurs d'assignation
int c = 5;
c += 3;          // Équivalent à c = c + 3 (c devient 8)
c -= 2;          // Équivalent à c = c - 2 (c devient 6)
c *= 2;          // Équivalent à c = c * 2 (c devient 12)
c /= 3;          // Équivalent à c = c / 3 (c devient 4)

// Opérateur instanceof
String texte = "Java";
System.out.println(texte instanceof String);  // true

🔀 Structures conditionnelles

Java utilise if, else if et else pour les conditions. Les blocs de code sont délimités par des accolades {}.

// Structure if simple
int age = 20;

if (age >= 18) {
    System.out.println("Vous êtes majeur");
} else {
    System.out.println("Vous êtes mineur");
}

// Structure if/else if/else
age = 15;

if (age >= 18) {
    System.out.println("Vous êtes majeur");
    System.out.println("Vous pouvez voter");
} else if (age >= 13) {
    System.out.println("Vous êtes adolescent");
} else if (age >= 6) {
    System.out.println("Vous êtes enfant");
} else {
    System.out.println("Vous êtes un bébé");
}

// Conditions multiples
int note = 85;
String mention;

if (note >= 90) {
    mention = "Excellent";
} else if (note >= 80) {
    mention = "Très bien";
} else if (note >= 70) {
    mention = "Bien";
} else if (note >= 60) {
    mention = "Assez bien";
} else {
    mention = "Insuffisant";
}

System.out.println("Votre mention : " + mention);

// Opérateur ternaire (expression conditionnelle)
age = 20;
String statut = (age >= 18) ? "Majeur" : "Mineur";
System.out.println(statut);

// Conditions avec &&/||
age = 25;
boolean permis = true;

if (age >= 18 && permis) {
    System.out.println("Vous pouvez conduire");
} else {
    System.out.println("Vous ne pouvez pas conduire");
}

// Switch-case
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("Autre jour");
}

🔄 Boucles

Java propose plusieurs types de boucles : for (classique et enhanced), while et do-while :

// Boucle for classique
for (int i = 0; i < 5; i++) {
    System.out.println(i);  // Affiche 0, 1, 2, 3, 4
}

// Boucle for avec début et fin
for (int i = 1; i <= 5; i++) {
    System.out.println(i);  // Affiche 1, 2, 3, 4, 5
}

// Boucle for avec pas
for (int i = 0; i < 10; i += 2) {
    System.out.println(i);  // Affiche 0, 2, 4, 6, 8
}

// Enhanced for loop (for-each) avec tableau
String[] fruits = {"pomme", "banane", "orange"};
for (String fruit : fruits) {
    System.out.println("J'aime les " + fruit);
}

// Boucle for classique avec tableau
for (int i = 0; i < fruits.length; i++) {
    System.out.println(i + ": " + fruits[i]);
}

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

// Boucle while avec break
compteur = 0;
while (true) {
    System.out.println(compteur);
    compteur++;
    if (compteur >= 5) {
        break;  // Sortir de la boucle
    }
}

// continue (passer à l'itération suivante)
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {  // Si i est pair
        continue;      // Passer au suivant
    }
    System.out.println(i);  // Affiche seulement les impairs: 1, 3, 5, 7, 9
}

// Boucle do-while (exécute au moins une fois)
int x = 0;
do {
    System.out.println(x);
    x++;
} while (x < 5);

⚙️ Méthodes

Les méthodes permettent de réutiliser du code. En Java, on définit une méthode avec un type de retour, un nom et des paramètres. Les méthodes peuvent retourner des valeurs avec return.

public class MethodesExemple {
    // Méthode simple (sans paramètres)
    public static void direBonjour() {
        System.out.println("Bonjour !");
    }
    
    // Méthode avec paramètres
    public static String saluer(String nom) {
        return "Bonjour, " + nom + " !";
    }
    
    // Méthode avec plusieurs paramètres
    public static int additionner(int a, int b) {
        return a + b;
    }
    
    // Méthode avec surcharge (même nom, paramètres différents)
    public static int additionner(int a, int b, int c) {
        return a + b + c;
    }
    
    // Méthode avec type de retour void
    public static void afficherInfo(String nom, int age) {
        System.out.println(nom + " a " + age + " ans");
    }
    
    // Méthode principale
    public static void main(String[] args) {
        direBonjour();  // Appel de la méthode
        String message = saluer("Java");
        System.out.println(message);  // "Bonjour, Java !"
        
        int resultat = additionner(5, 3);
        System.out.println(resultat);  // 8
        
        int resultat2 = additionner(1, 2, 3);
        System.out.println(resultat2);  // 6
        
        afficherInfo("Bassirou", 25);
    }
}

📋 Tableaux

Les tableaux en Java sont des structures de données de taille fixe. Ils permettent de stocker plusieurs éléments du même type.

// Création de tableaux
int[] nombres = {1, 2, 3, 4, 5};
String[] fruits = {"pomme", "banane", "orange"};

// Création avec taille
int[] tableau = new int[5];  // Tableau de 5 entiers (initialisés à 0)

// Accès aux éléments (index commence à 0)
System.out.println(fruits[0]);        // "pomme" (premier élément)
System.out.println(fruits[fruits.length - 1]);  // "orange" (dernier élément)

// Modification
fruits[1] = "mangue";    // Remplacer "banane" par "mangue"

// Longueur du tableau
System.out.println(fruits.length);  // 3

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

// Parcourir avec enhanced for (for-each)
for (String fruit : fruits) {
    System.out.println("J'aime les " + fruit);
}

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

// Accès aux éléments
System.out.println(matrice[0][0]);  // 1
System.out.println(matrice[1][2]);  // 6

// Parcourir une matrice
for (int i = 0; i < matrice.length; i++) {
    for (int j = 0; j < matrice[i].length; j++) {
        System.out.print(matrice[i][j] + " ");
    }
    System.out.println();
}

🏗️ Programmation Orientée Objet

Java est un langage orienté objet. Une classe est un modèle pour créer des objets. Les objets ont des attributs (données) et des méthodes (fonctions).

// Définir une classe
class Personne {
    // Attributs d'instance
    private String nom;
    private int age;
    
    // Constructeur
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
    
    // Méthode d'instance
    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;
    }
}

// Classe principale
public class ExemplePOO {
    public static void main(String[] args) {
        // Créer des objets (instances)
        Personne personne1 = new Personne("Bassirou", 25);
        Personne personne2 = new Personne("Aminata", 30);
        
        // Utiliser les méthodes
        personne1.sePresenter();
        personne2.sePresenter();
        
        // Accéder aux attributs via getters
        System.out.println(personne1.getNom());
        System.out.println(personne1.getAge());
    }
}

📚 Collections

Java fournit le framework Collections pour gérer des groupes d'objets. Les principales collections sont ArrayList, HashMap, HashSet, etc.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

// ArrayList (liste dynamique)
ArrayList<String> fruits = new ArrayList<>();
fruits.add("pomme");
fruits.add("banane");
fruits.add("orange");
fruits.add(1, "mangue");  // Insérer à l'index 1

System.out.println(fruits.get(0));  // "pomme"
System.out.println(fruits.size());  // 4

fruits.remove("banane");
fruits.remove(0);

// HashMap (dictionnaire clé-valeur)
HashMap<String, Integer> ages = new HashMap<>();
ages.put("Bassirou", 25);
ages.put("Aminata", 30);
ages.put("Ibrahima", 28);

System.out.println(ages.get("Bassirou"));  // 25
System.out.println(ages.containsKey("Aminata"));  // true

// Parcourir un HashMap
for (String nom : ages.keySet()) {
    System.out.println(nom + " a " + ages.get(nom) + " ans");
}

// HashSet (ensemble unique)
HashSet<String> villes = new HashSet<>();
villes.add("Dakar");
villes.add("Thiès");
villes.add("Dakar");  // Ignoré (déjà présent)

System.out.println(villes.size());  // 2

⚠️ Gestion des exceptions

Java utilise try-catch pour gérer les erreurs. Les exceptions permettent de gérer les erreurs de manière élégante sans faire planter le programme.

// Try-catch simple
try {
    int resultat = 10 / 0;  // Division par zéro
} catch (ArithmeticException e) {
    System.out.println("Erreur : Division par zéro !");
}

// Try-catch avec plusieurs catch
try {
    int[] tableau = {1, 2, 3};
    System.out.println(tableau[5]);  // Index hors limites
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Erreur : Index invalide !");
} catch (Exception e) {
    System.out.println("Erreur générale : " + e.getMessage());
}

// Try-catch-finally
try {
    // Code qui peut générer une exception
    int nombre = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Erreur : Format de nombre invalide !");
} finally {
    System.out.println("Ce code s'exécute toujours");
}

// Lancer une exception
public static void verifierAge(int age) throws IllegalArgumentException {
    if (age < 0) {
        throw new IllegalArgumentException("L'âge ne peut pas être négatif");
    }
    System.out.println("Âge valide : " + age);
}

📁 Manipulation de fichiers

Java permet de lire et écrire dans des fichiers. On utilise FileReader, FileWriter, BufferedReader, etc.

import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

// Écrire dans un fichier
try {
    FileWriter writer = new FileWriter("fichier.txt");
    writer.write("Bonjour Java !");
    writer.close();
    System.out.println("Fichier écrit avec succès");
} catch (IOException e) {
    System.out.println("Erreur lors de l'écriture : " + e.getMessage());
}

// Lire un fichier
try {
    FileReader reader = new FileReader("fichier.txt");
    BufferedReader bufferedReader = new BufferedReader(reader);
    String ligne;
    while ((ligne = bufferedReader.readLine()) != null) {
        System.out.println(ligne);
    }
    bufferedReader.close();
} catch (IOException e) {
    System.out.println("Erreur lors de la lecture : " + e.getMessage());
}

// Utiliser try-with-resources (fermeture automatique)
try (FileWriter writer = new FileWriter("fichier.txt")) {
    writer.write("Bonjour Java !\n");
    writer.write("Ceci est la deuxième ligne\n");
    System.out.println("Fichier écrit avec succès");
} catch (IOException e) {
    System.out.println("Erreur : " + e.getMessage());
}

// Lire ligne par ligne avec try-with-resources
try (BufferedReader reader = new BufferedReader(new FileReader("fichier.txt"))) {
    String ligne;
    while ((ligne = reader.readLine()) != null) {
        System.out.println(ligne);
    }
} catch (IOException e) {
    System.out.println("Erreur lors de la lecture : " + e.getMessage());
}

// Ajouter à un fichier (mode append)
try (FileWriter writer = new FileWriter("fichier.txt", true)) {
    writer.write("Nouvelle ligne ajoutée\n");
    System.out.println("Ligne ajoutée avec succès");
} catch (IOException e) {
    System.out.println("Erreur : " + e.getMessage());
}

💡 Note importante : En Java, il est recommandé d'utiliser try-with-resources pour garantir la fermeture automatique des fichiers. Cela évite les fuites de ressources et simplifie le code.

🎓 Prochaines étapes

Félicitations ! Vous avez maintenant une solide base en Java.

✅ Ce que vous avez appris :

  • Syntaxe Java et variables
  • Types de données (primitifs et objets)
  • Opérateurs (arithmétiques, comparaison, logiques)
  • Structures conditionnelles (if, else if, else, switch)
  • Boucles (for, while, do-while, enhanced for)
  • Méthodes (définition, paramètres, return, surcharge)
  • Tableaux (déclaration, manipulation, multidimensionnels)
  • Programmation Orientée Objet (classes, objets, constructeurs)
  • Collections (ArrayList, HashMap, HashSet)
  • Gestion des exceptions (try-catch-finally)
  • Manipulation de fichiers (FileReader, FileWriter, BufferedReader)

🚀 Pour aller plus loin :

  • Héritage et Polymorphisme - Concepts avancés de la POO
  • Interfaces et Classes abstraites - Abstraction en Java
  • Packages et Modules - Organisation du code
  • Spring Framework - Framework pour applications d'entreprise
  • Développement Android - Créer des applications mobiles
  • Microservices - Architecture distribuée avec Spring Cloud
❮ Précédent: Python Pratiquer avec des exercices ❯
Cliquer pour discuter avec NiangProgrammeur
NiangProgrammeur
En ligne

Bonjour ! 👋

Comment puis-je vous aider aujourd'hui ?

Ouvrir WhatsApp