INTRODUCTION
1. Introduction à Java
Java est un langage multi-plateforme qui permet de
créer des applications pouvant fonctionner sur différents
systèmes d’exploitation. Il est connu pour sa philosophie
“Write Once, Run Anywhere” (écris une fois, exécute
partout).
Caractéristiques de Java :
• Simple : facile à apprendre.
• Orienté Objet : tout dans Java est orienté objet.
• Portable : code utilisable sur plusieurs
systèmes d’exploitation.
• Sécurisé : intégré avec des fonctionnalités de
sécurité avancées.
• Robuste : gestion automatique de la mémoire
et des erreurs.
2. Installation de Java (JDK)
Avant de commencer à programmer, tu dois installer le
Java Development Kit (JDK) et un environnement de
développement intégré (IDE) comme NetBeans ou
IntelliJ IDEA.
1. Télécharge JDK depuis le site d’Oracle.
2. Installe-le en suivant les instructions pour ton
système (Windows, macOS, Linux).
3. Configure les variables d’environnement pour
que le système puisse reconnaître Java (ajoute le
chemin de java dans la variable PATH).
3. Structure d’un Programme Java
Chaque programme Java a la même structure de base.
Voici un programme simple :
public class HelloWorld {
public static void main(String[] args) {
[Link]("Hello, World!");
}
}
Explication :
• public class HelloWorld : Déclare une classe
nommée HelloWorld. En Java, tout est contenu dans
des classes.
• public static void main(String[] args) : Méthode
principale où l’exécution commence. C’est obligatoire
dans tout programme Java.
• [Link]("Hello, World!"); : Affiche le
texte Hello, World! sur la console.
4. Variables et Types de Données
Les variables sont des emplacements en mémoire qui
stockent des données. Les types de données définissent
la nature des données que tu peux stocker dans une
variable.
Types de données primitifs en Java :
• int : pour les nombres entiers (ex : 10, -5).
• double : pour les nombres à virgule flottante (ex
: 10.5, -2.7).
• char : pour les caractères (ex : ‘A’, ‘b’).
• boolean : pour les valeurs vraies ou fausses
(true, false).
Exemple :
int age = 25;
double salaire = 2500.50;
char lettre = 'A';
boolean estEtudiant = true;
5. Opérateurs en Java
Les opérateurs sont utilisés pour effectuer des
opérations sur des variables et des valeurs.
Quelques opérateurs importants :
• Opérateurs arithmétiques : +, -, *, /, %.
• Opérateurs de comparaison : ==, !=, >, <, >=,
<=.
• Opérateurs logiques : && (et), || (ou), ! (non).
Exemple :
int a = 10;
int b = 20;
boolean result = (a < b); // result est true car a est
inférieur à b
6. Structures de contrôle
Les structures de contrôle permettent de contrôler le flux
du programme.
6.1. Les instructions conditionnelles (if/else)
int age = 18;
if (age >= 18) {
[Link]("Vous êtes majeur.");
} else {
[Link]("Vous êtes mineur.");
}
6.2. Les boucles (for, while)
Les boucles sont utilisées pour répéter une série
d’instructions.
• Boucle for :
for (int i = 0; i < 5; i++) {
[Link](i); // Affiche les nombres de 0 à 4
}
• Boucle while :
int i = 0;
while (i < 5) {
[Link](i);
i++;
}
7. Méthodes en Java
Une méthode est un bloc de code qui accomplit une
tâche spécifique. Cela permet de réutiliser du code.
Exemple de méthode :
public class Exemple {
public static void main(String[] args) {
saluer(); // Appel à la méthode saluer
}
// Définition d'une méthode
public static void saluer() {
[Link]("Bonjour!");
}
}
8. Programmation Orientée Objet (POO)
Java est un langage orienté objet, ce qui signifie que le
code est structuré autour d’objets.
Concepts clés :
• Classe : Plan à partir duquel les objets sont
créés.
• Objet : Instance d’une classe.
• Attributs : Propriétés/variables définies dans
une classe.
• Méthodes : Comportement/fonctions d’une
classe.
Exemple :
public class Voiture {
String marque;
int annee;
// Constructeur
public Voiture(String marque, int annee) {
[Link] = marque;
[Link] = annee;
}
// Méthode pour afficher les infos
public void afficherDetails() {
[Link]("Marque : " + marque + ", Année
: " + annee);
}
public static void main(String[] args) {
Voiture maVoiture = new Voiture("Toyota", 2020);
[Link]();
}
}
9. Gestion des Exceptions
Les exceptions sont des erreurs qui surviennent pendant
l’exécution d’un programme. Java permet de les gérer
pour éviter que le programme ne plante.
Exemple :
try {
int division = 10 / 0;
} catch (ArithmeticException e) {
[Link]("Erreur : division par zéro !");
}
10. Introduction aux Tableaux
Un tableau permet de stocker plusieurs valeurs du
même type dans une seule variable.
Exemple de tableau :
int[] nombres = {1, 2, 3, 4, 5};
[Link](nombres[0]); // Affiche le premier
élément du tableau
11. Les Classes et Objets en Java
En Java, la Programmation Orientée Objet (POO)
repose sur la création de classes et d’objets. Une classe
définit la structure et le comportement d’un objet, tandis
qu’un objet est une instance concrète d’une classe.
Définir une classe :
public class Personne {
// Attributs de la classe
String nom;
int age;
// Constructeur de la classe
public Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
}
// Méthode pour afficher les informations d'une
personne
public void afficherDetails() {
[Link]("Nom : " + nom + ", Âge : " +
age);
}
}
Créer des objets :
public class Main {
public static void main(String[] args) {
// Création de deux objets de type Personne
Personne personne1 = new Personne("Alice", 30);
Personne personne2 = new Personne("Bob", 25);
// Appel de la méthode afficherDetails
[Link]();
[Link]();
}
}
12. Encapsulation
L’encapsulation est un des principes fondamentaux de la
POO. Elle consiste à protéger les données des objets en
les rendant privées, et en fournissant des méthodes
publiques pour y accéder et les modifier (les getters et
setters).
Exemple d’encapsulation :
public class CompteBancaire {
// Attributs privés
private String titulaire;
private double solde;
// Constructeur
public CompteBancaire(String titulaire, double solde) {
[Link] = titulaire;
[Link] = solde;
}
// Getter pour accéder au titulaire
public String getTitulaire() {
return titulaire;
}
// Setter pour modifier le titulaire
public void setTitulaire(String titulaire) {
[Link] = titulaire;
}
// Getter pour accéder au solde
public double getSolde() {
return solde;
}
// Méthode pour déposer de l'argent
public void deposer(double montant) {
solde += montant;
}
// Méthode pour retirer de l'argent
public void retirer(double montant) {
if (montant <= solde) {
solde -= montant;
} else {
[Link]("Solde insuffisant !");
}
}
}
13. Héritage en Java
L’héritage permet de créer une nouvelle classe qui hérite
des attributs et méthodes d’une classe existante. Cela
permet de réutiliser du code.
Exemple d’héritage :
// Classe de base
public class Animal {
public void parler() {
[Link]("L'animal fait un bruit");
}
}
// Classe dérivée (héritant d'Animal)
public class Chien extends Animal {
@Override
public void parler() {
[Link]("Le chien aboie");
}
}
// Utilisation de l'héritage
public class Main {
public static void main(String[] args) {
Animal animal = new Animal();
[Link](); // Sortie : L'animal fait un bruit
Chien chien = new Chien();
[Link](); // Sortie : Le chien aboie
}
}
14. Polymorphisme
Le polymorphisme en Java permet à un objet de prendre
différentes formes. En Java, cela se manifeste
généralement via l’héritage et l’interface, et permet de
manipuler des objets de différentes classes via une
référence commune.
Exemple de polymorphisme :
public class Main {
public static void main(String[] args) {
Animal monAnimal = new Chien(); // Un chien est
aussi un animal
[Link](); // Sortie : Le chien aboie
}
}
15. Interfaces en Java
Une interface en Java est un ensemble de méthodes
abstraites que toute classe peut implémenter.
Contrairement à l’héritage classique (où une classe ne
peut hériter que d’une seule autre classe), une classe
peut implémenter plusieurs interfaces. Les interfaces
permettent de définir un contrat que les classes
implémentantes doivent respecter.
Exemple d’interface :
public interface Animal {
void parler();
}
Implémentation de l’interface :
public class Chien implements Animal {
@Override
public void parler() {
[Link]("Le chien aboie");
}
}
public class Chat implements Animal {
@Override
public void parler() {
[Link]("Le chat miaule");
}
}
Utilisation d’une interface :
public class Main {
public static void main(String[] args) {
Animal monChien = new Chien();
Animal monChat = new Chat();
[Link](); // Affiche : Le chien aboie
[Link](); // Affiche : Le chat miaule
}
}
16. Collections en Java
Les collections sont des structures de données
dynamiques qui permettent de stocker, récupérer et
manipuler des ensembles d’objets. Les collections les
plus courantes en Java sont les listes, les ensembles
(sets) et les maps (dictionnaires).
Les Listes (ArrayList)
Une ArrayList est une collection ordonnée qui permet de
stocker des éléments en les indexant.
import [Link];
public class Main {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
// Ajouter des éléments
[Link]("Pomme");
[Link]("Banane");
[Link]("Orange");
// Accéder à un élément par son index
[Link]([Link](0)); // Affiche : Pomme
// Parcourir la liste
for (String fruit : fruits) {
[Link](fruit);
}
// Taille de la liste
[Link]("Taille de la liste : " +
[Link]());
}
}
Les Sets (HashSet)
Un HashSet est une collection qui ne contient pas de
doublons.
import [Link];
public class Main {
public static void main(String[] args) {
HashSet<String> fruits = new HashSet<>();
// Ajouter des éléments
[Link]("Pomme");
[Link]("Banane");
[Link]("Orange");
[Link]("Pomme"); // Ignoré, car déjà présent
// Parcourir le set
for (String fruit : fruits) {
[Link](fruit);
}
// Taille du set
[Link]("Taille du set : " + [Link]());
}
}
Les Maps (HashMap)
Une HashMap est une collection qui associe des clés à
des valeurs. Elle permet de stocker des paires
clé/valeur.
import [Link];
public class Main {
public static void main(String[] args) {
HashMap<String, Integer> ages = new
HashMap<>();
// Ajouter des paires clé/valeur
[Link]("Alice", 30);
[Link]("Bob", 25);
[Link]("Charlie", 35);
// Accéder à une valeur via sa clé
[Link]("L'âge de Bob est : " +
[Link]("Bob"));
// Parcourir la map
for (String name : [Link]()) {
[Link](name + " a " +
[Link](name) + " ans.");
}
}
}
17. Lambda Expressions
Les expressions lambda en Java permettent d’écrire des
fonctions anonymes de manière concise. Elles sont
principalement utilisées avec des interfaces
fonctionnelles, comme celles trouvées dans les API des
collections Java.
Exemple d’utilisation d’une expression lambda :
import [Link];
public class Main {
public static void main(String[] args) {
ArrayList<String> noms = new ArrayList<>();
[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");
// Utilisation d'une expression lambda pour
parcourir et afficher les noms
[Link](nom -> [Link](nom));
}
}
18. Streams API
L’API Stream de Java 8 permet de traiter des collections
de manière déclarative en utilisant des opérations de
type filtrage, tri, et réduction. C’est un outil puissant pour
manipuler des collections de données.
Exemple d’utilisation des Streams :
import [Link];
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
List<String> noms = new ArrayList<>();
[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");
[Link]("David");
// Filtrer les noms qui commencent par "A"
List<String> nomsFiltre = [Link]()
.filter(nom ->
[Link]("A"))
.collect([Link]());
[Link]([Link]::println); // Affiche :
Alice
}
}
19. Threads et Concurrence
Java permet de créer des programmes multi-threadés
pour exécuter plusieurs tâches simultanément. Chaque
thread représente un flux d’exécution indépendant.
Créer un thread en implémentant Runnable :
public class MonThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
[Link]("MonThread - itération " + i);
}
}
public static void main(String[] args) {
MonThread monThread = new MonThread();
Thread thread = new Thread(monThread);
[Link]();
}
}
Créer un thread en étendant la classe Thread :
public class MonThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
[Link]("MonThread - itération " + i);
}
}
public static void main(String[] args) {
MonThread thread = new MonThread();
[Link]();
}
}
