COURS DE PROGRAMMATION JAVA
Classes Préparatoires
2ᵉᵐᵉ année
SEMAINE 1
Fondamentaux, JVM et Environnement
Chapitres abordés :
Chapitre 1 — Présentation du langage Java
Chapitre 2 — Paradigmes et typologie des langages
Chapitre 3 — La Programmation Orientée Objet (POO)
Chapitre 4 — Environnement de développement
Chapitre 5 — Structure d’un programme Java
Année académique 2025-2026
SOMMAIRE
Avant-propos : Pourquoi apprendre Java en CPGE ? .......................................................... 3
Chapitre 1 — Présentation du langage Java ......................................................................... 3
1.1 Qu’est-ce que Java ? ................................................................................................... 3
1. La Syntaxe ...................................................................................................................... 3
2. La Sémantique ............................................................................................................... 3
1.2 La Machine Virtuelle Java (JVM) ................................................................................. 4
1.3 Java vs C++ .................................................................................................................. 4
Chapitre 2 — Paradigmes et typologie des langages ........................................................... 5
2.1 Les quatre paradigmes majeurs................................................................................... 5
Paradigme procédural (ou impératif).................................................................................. 5
Paradigme fonctionnel ........................................................................................................ 5
Paradigme orienté objet (POO).......................................................................................... 5
Paradigme générique ......................................................................................................... 5
2.2 Les trois niveaux d’abstraction ..................................................................................... 5
2.3 Les types de langages selon l’exécution ..................................................................... 6
Chapitre 3 — La Programmation Orientée Objet (POO) ....................................................... 7
3.1 Du procédural à l’objet ..................................................................................................... 7
3.2 Objet et Classe ............................................................................................................. 7
3.3 Les quatre piliers de la POO ........................................................................................ 7
Chapitre 4 — Environnement de développement.................................................................. 8
4.1 Le JDK 25 LTS ................................................................................................................. 8
4.2 Les environnements de développement (IDEs) .......................................................... 8
4.3 Installation et configuration .......................................................................................... 8
Chapitre 5 — Structure d’un programme Java ...................................................................... 9
5.1 La classe et le fichier .................................................................................................... 9
5.2 Compilation et exécution .............................................................................................. 9
Résumé — Tableau récapitulatif.......................................................................................... 10
Checklist de validation.......................................................................................................... 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Avant-propos : Pourquoi apprendre Java en CPGE ?
Dans le monde scientifique et industriel d’aujourd’hui, la programmation n’est plus une
compétence optionnelle : c’est un outil fondamental. Java s’impose naturellement comme le
langage idéal pour débuter en programmation orientée objet pour plusieurs raisons :
• Rigueur et structure : Sa syntaxe stricte vous force à adopter de bonnes habitudes
dès le départ.
• Reconnaissance académique : Langage de référence dans les concours.
• Pertinence industrielle : Utilisé dans les applications Android, les systèmes
bancaires, le Big Data et les applications d’entreprise (Spring).
• Écosystème complet : Une bibliothèque standard immense (API Java) qui vous
permet de réaliser pratiquement n’importe quelle tâche.
Chapitre 1 — Présentation du langage Java
1.1 Qu’est-ce que Java ?
Java est un langage de programmation créé par Sun Microsystems (aujourd’hui Oracle) en
1995. Sa particularité fondamentale est qu’un programme Java peut s’exécuter sur n’importe
quel système d’exploitation (Windows, macOS, Linux) sans modification.
Le principe WORA : Write Once, Run Anywhere — « Écrire une fois, exécuter partout ».
En programmation classique (comme le C), le code est compilé directement en langage
machine (0 et 1) spécifique à un processeur. Un programme compilé pour Windows ne
fonctionne pas sur Mac. Java résout ce problème d’incompatibilité en compilant non pas pour
une machine physique, mais pour une machine virtuelle universelle.
Un langage informatique est un système formel composé de :
• Syntaxe : Règles d’écriture (structure, ponctuation, mots-clés).
• Sémantique : Signification des instructions et comportement à l’exécution.
• Paradigmes : Modèles de programmation (impératif, fonctionnel, orienté objet, etc.).
1. La Syntaxe
L’ensemble des règles qui définissent la structure correcte des instructions (la « grammaire »
du code). Une erreur de syntaxe empêche l’exécution du programme.
Exemple :
[Link]("Bonjour"); // Syntaxe correcte
[Link] "Bonjour" // Erreur de syntaxe : parenthèses
manquantes
2. La Sémantique
Le sens donné aux instructions. Un code peut être syntaxiquement correct mais produire un
résultat logique erroné (erreur de logique).
Exemple :
var rayon = 5;
Page 3 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
var aire = 2 * [Link] * rayon; // Syntaxe correcte, sémantique
fausse
// Formule du périmètre au lieu de l’aire !
1.2 La Machine Virtuelle Java (JVM)
La JVM (Java Virtual Machine) est un environnement d’exécution abstrait. Elle constitue la
couche d’abstraction entre votre code et le matériel physique.
Processus d’exécution :
Fichier source (.java) --[javac]--> Bytecode (.class) --[JVM]-->
Exécution
La JVM effectue trois opérations essentielles :
• Charge : le bytecode (fichiers .class).
• Vérifie : la sécurité et la cohérence du code.
• Interprète ou compile à la volée : via le JIT (Just-In-Time) : conversion du bytecode
en instructions machine natives.
1.3 Java vs C++
Critère Java C++
Paradigme Orienté objet pur Multi-paradigme (procédural,
objet, générique)
Exécution Bytecode + JVM Compilation native directe
Portabilité Universelle (WORA) Dépendante de la plateforme
Gestion mémoire Automatique (Garbage Manuelle (new / delete)
Collector)
Héritage multiple Non (interfaces uniquement) Oui
Usage typique Enterprise, Android, Big Data Systèmes, jeux, temps réel
Page 4 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Chapitre 2 — Paradigmes et typologie des langages
2.1 Les quatre paradigmes majeurs
Un paradigme est un modèle de pensée qui définit comment structurer son code.
Paradigme Concept clé Exemple en Java
Procédural Suite d’instructions et de Une méthode main qui exécute
fonctions des étapes
Orienté Objet Objets regroupant données et class Point { double x; double
comportements distance(...) }
Fonctionnel Fonctions pures, immutabilité [Link]().filter(...).map(...)
Générique Code indépendant du type class Boite<T> { T contenu; }
Paradigme procédural (ou impératif)
Le programme est une suite d’instructions exécutées séquentiellement, organisées en
fonctions et procédures qui manipulent des données externes.
Paradigme fonctionnel
Le programme est construit en composant et en appliquant des fonctions mathématiques. On
évite les effets de bord et les états mutables.
Paradigme orienté objet (POO)
Le programme est organisé autour d’objets qui encapsulent à la fois des données (attributs)
et des comportements (méthodes).
Paradigme générique
Écrire du code indépendant des types de données, qui fonctionne avec n’importe quel type
sans duplication.
Exemple (Java) :
class Boite<T> {
T contenu;
}
Java est historiquement orienté objet pur, mais supporte aussi la programmation générique.
2.2 Les trois niveaux d’abstraction
Niveau Langages Caractéristiques
Bas Langage machine, Proche du processeur, binaire 0/1
Assembleur
Moyen C Contrôle fin de la mémoire, syntaxe lisible
Haut Java, Python, C++ Abstraction élevée, proche du
raisonnement humain
Page 5 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Java étant un langage de haut niveau, vous n’avez pas à gérer la mémoire manuellement : le
Garbage Collector libère automatiquement la mémoire non utilisée.
2.3 Les types de langages selon l’exécution
Type Mécanisme Avantages Inconvénients Exemples
Interprété Exécution ligne Portable, Lent à Python,
par ligne débogage l’exécution JavaScript
rapide
Compilé Binaire natif avant Performances Non portable C, C++, Rust
exécution optimales
Hybride Bytecode + VM + Portable + Nécessite une Java
JIT performant VM
Java est un langage hybride : il compile en bytecode universel, puis la JVM interprète et
optimise via la compilation JIT.
Page 6 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Chapitre 3 — La Programmation Orientée Objet (POO)
3.1 Du procédural à l’objet
Traditionnellement, la programmation était procédurale : une suite d’instructions et de
fonctions agissant sur des données. La POO représente un changement de paradigme : on
conçoit le programme comme un ensemble d’objets qui interagissent entre eux.
3.2 Objet et Classe
Concept Définition Analogie
Classe Modèle, « plan » de construction Moule à gâteaux
Objet Instance concrète d’une classe Gâteau fabriqué avec le moule
Attributs Données définissant l’état de Couleur, vitesse d’une voiture
l’objet
Méthodes Comportements et actions accelerer(), freiner()
possibles
3.3 Les quatre piliers de la POO
• Encapsulation : Protection des données internes. On cache les détails
d’implémentation et on expose uniquement ce qui est nécessaire.
• Héritage : Une classe récupère les propriétés d’une autre. Exemple : Carré hérite de
Rectangle.
• Polymorphisme : Une variable de type Forme peut contenir un Cercle, un Rectangle
ou un Carré. Un même appel de méthode (aire()) se comporte différemment selon
l’objet réel.
• Abstraction : Masquer la complexité technique. Vous utilisez [Link]() sans
connaître l’algorithme interne.
Page 7 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Chapitre 4 — Environnement de développement
4.1 Le JDK 25 LTS
Pour coder en Java, vous aurez besoin du JDK (Java Development Kit), qui inclut le
compilateur javac et la JVM. Ce cours utilise Java 25 LTS (Long Term Support), stable.
Le JDK contient :
• Le compilateur : javac, qui transforme le code source en bytecode.
• La JVM : pour exécuter les programmes compilés.
• Les bibliothèques standard : [Link], Math, collections…
• Les outils de débogage : pour analyser et corriger les erreurs.
Installation : téléchargez l’installateur depuis le site d’Oracle ou Adoptium
([Link]
4.2 Les environnements de développement (IDEs)
IDE Avantages Inconvénients
VS Code Léger, gratuit, excellent support Java Nécessite l’installation
moderne d’extensions
Eclipse Gratuit, historiquement utilisé en CP Interface datée, lourd
IntelliJ IDEA Le plus complet, refactoring intelligent Version Ultimate payante
Cursor Intégration poussée de l’IA, très Dépendance à l’IA, peut être
productif payant
NetBeans Facile à prendre en main, tout-en-un Moins flexible, un peu lourd
pour Java
Recommandation : Pour apprendre Java, privilégiez VS Code + Extension Pack for Java
(Microsoft). Les outils à IA peuvent masquer la compréhension des fondamentaux si vous
n’avez pas encore acquis les bases. Utilisez-les comme aide ponctuelle, pas comme substitut
à l’apprentissage.
4.3 Installation et configuration
Pour mettre en place votre environnement de travail, suivez ces étapes :
• Télécharger le JDK 2 depuis Oracle ou Adoptium.
• Configurer le Path système pour pointer vers le dossier jdk-25/bin.
• Vérifier l’installation dans le terminal : java --version
• Installer VS Code et l’extension « Extension Pack for Java ».
Lien VS Code : [Link]
Configuration du JDK dans VS Code :
Appuyez sur Ctrl+Shift+P, tapez « Java : Configure Java Runtime » et sélectionnez votre JDK
25 installé.
Structure d’un projet Java dans VS Code :
Semaine1/
├── src/ (fichiers sources .java)
└── bin/ (fichiers compilés .class — généré automatiquement)
Page 8 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Création du projet (via la palette de commandes) :
• Ouvrir VS Code.
• Ouvrir la palette de commandes : Ctrl+Shift+P.
• Taper « Java: Create Java Project » et appuyer sur Entrée.
• Choisir « No build tools » (option la plus simple pour commencer).
• Sélectionner un dossier parent et donner un nom au projet.
Chapitre 5 — Structure d’un programme Java
5.1 La classe et le fichier
En Java, tout concept est rangé dans une classe. Le fichier source porte le même nom que
la classe publique (sensibilité à la casse).
// Fichier : [Link]
public class Bonjour {
public static void main(String[] args) {
[Link]("Bonjour les CPGE !");
}
}
Analyse de la signature main :
Mot-clé Signification
public Accessible partout (la JVM doit trouver ce point d’entrée).
static Appartient à la classe ; pas besoin d’objet pour l’appeler.
void Ne retourne aucune valeur.
main Nom obligatoire, point d’entrée unique du programme.
String[] args Arguments passés par la ligne de commande.
5.2 Compilation et exécution
Méthode classique (tous projets) :
javac [Link] # Compile → génère [Link]
java Bonjour # Exécute via la JVM (sans l’extension .class)
Nouveauté Java 11+ (scripts et apprentissage) :
java [Link] # Compilation implicite + exécution directe
Attention : Cette méthode fonctionne uniquement pour les programmes à un seul fichier.
Pour les projets multi-fichiers, utilisez javac + java.
Page 9 / 10
Cours Java — Semaine 1 : Fondamentaux, JVM et Environnement | CP 2ᵉᵐᵉ année
Résumé — Tableau récapitulatif
Notion À retenir
JVM Machine virtuelle qui exécute le bytecode universel.
JDK 25 LTS Version stable.
WORA Write Once, Run Anywhere — Écrire une fois, exécuter partout.
Structure public class Nom { public static void main(String[] args) { … } }
Compilation javac [Link] → java NomClasse
POO Classe = moule, Objet = instance, 4 piliers.
Héritage extends pour la relation « est-un » (Carré est un Rectangle).
Polymorphisme Forme[] tab = { new Rectangle(…), new Cercle(…) }
Encapsulation Attributs private, accès via getters/setters.
Checklist de validation
Avant de passer à la suite, vérifiez que vous êtes capables de :
□ Expliquer le rôle de la JVM et du bytecode.
□ Installer le JDK 25 et configurer le Path.
□ Compiler et exécuter un programme depuis le terminal.
□ Créer un projet Java dans VS Code.
□ Identifier les quatre paradigmes de programmation.
□ Expliquer les quatre piliers de la POO.
« Le seul moyen d’apprendre un nouveau langage de programmation est d’écrire des programmes
avec. »
— Dennis Ritchie, créateur du langage C
Page 10 / 10