Close
Objectif : Apprendre à utiliser la méthode System.out.println() pour afficher du texte à l’écran.
Énoncé : Écrivez un programme Java qui affiche le message suivant : "Hello, World!".
// La classe principale du programme
public class HelloWorld {
public static void main(String[] args) {
// Affiche le message "Hello, World!" à l'écran
System.out.println("Hello, World!");
}
}
Classe principale (HelloWorld) : En Java, tout programme doit être contenu dans une classe. Le nom de la classe doit correspondre au nom du fichier source. Par exemple, si votre fichier s’appelle HelloWorld.java, la classe doit aussi s’appeler HelloWorld.
Méthode main : C’est le point d’entrée de tout programme Java. Lorsque vous exécutez votre programme, c’est à partir de la méthode main que le code commence à s’exécuter. Le tableau String[] args permet de passer des arguments au programme via la ligne de commande (ceci est plus avancé et sera couvert plus tard).
System.out.println : Cette méthode fait partie de la classe System et sert à afficher des messages à l’écran. Le texte que vous voulez afficher est placé entre guillemets doubles " " et passé en paramètre de la méthode. Le println signifie « print line » et ajoute automatiquement un saut de ligne après l’affichage du message.
Objectif : Comprendre les variables et les types de données de base en Java.
Énoncé : Déclarez trois variables : un entier, un double et une chaîne de caractères. Assignez-leur des valeurs et affichez-les à l’écran.
public class Variables {
public static void main(String[] args) {
// Déclaration et initialisation des variables
int entier = 25;
double decimal = 3.14;
String texte = "Bonjour, Java!";
// Affichage des variables
System.out.println("Entier: " + entier);
System.out.println("Décimal: " + decimal);
System.out.println("Texte: " + texte);
}
}
Une variable est une sorte de « boîte » où l’on stocke des valeurs que l’on peut utiliser et manipuler dans le programme. En Java, il est nécessaire de préciser le type de chaque variable au moment de sa déclaration. Cela permet au compilateur de savoir quel genre de données la variable va contenir.
Types de données :
int : Ce type de variable est utilisé pour stocker des nombres entiers (sans virgule).double : Utilisé pour stocker des nombres décimaux (avec virgule).String : Type utilisé pour stocker des chaînes de caractères, c’est-à-dire du texte.
Initialisation : Après avoir déclaré une variable, vous pouvez lui assigner une valeur. Dans cet exemple, entier est initialisé avec la valeur 25, decimal avec 3.14, et texte avec "Bonjour, Java!".
Affichage avec System.out.println : On peut utiliser System.out.println pour afficher le contenu des variables. Le symbole + est utilisé pour concaténer du texte avec la valeur des variables. Par exemple, "Entier: " + entier affiche "Entier: 25".
Objectif : Pratiquer les opérations arithmétiques de base.
Énoncé : Écrivez un programme qui effectue les opérations suivantes sur deux nombres : addition, soustraction, multiplication et division.
public class Operations {
public static void main(String[] args) {
int a = 10;
int b = 5;
// Effectue et affiche les opérations mathématiques
System.out.println("Addition: " + (a + b));
System.out.println("Soustraction: " + (a - b));
System.out.println("Multiplication: " + (a * b));
System.out.println("Division: " + (a / b));
}
}
+ pour l’addition- pour la soustraction* pour la multiplication/ pour la division
Ordre des opérations : Java respecte l’ordre des opérations mathématiques (parenthèses, multiplication/division, addition/soustraction). Dans cet exemple, les opérations sont simples et s’exécutent dans l’ordre.
Affichage des résultats : Le programme utilise System.out.println pour afficher les résultats des opérations. Le code a + b calcule la somme des variables a et b, et le résultat est ensuite affiché.
Importance des parenthèses : Les parenthèses autour de chaque opération sont essentielles pour s’assurer que l’opération est effectuée avant d’être affichée. Sans parenthèses, Java pourrait interpréter a + b comme une chaîne de caractères suivie de la variable b.
Objectif : Apprendre à utiliser les structures conditionnelles.
Énoncé : Écrivez un programme qui demande à l’utilisateur son âge et affiche un message indiquant s’il est majeur ou mineur.
import java.util.Scanner;
public class AgeCheck {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Demande l'âge de l'utilisateur
System.out.print("Quel âge avez-vous ? ");
int age = scanner.nextInt();
// Vérifie si l'utilisateur est majeur ou mineur
if (age >= 18) {
System.out.println("Vous êtes majeur.");
} else {
System.out.println("Vous êtes mineur.");
}
}
}
Scanner : La classe Scanner est utilisée pour lire les entrées de l’utilisateur. Ici, on utilise new Scanner(System.in) pour créer un scanner qui lit les entrées depuis la console. La méthode nextInt() lit un entier entré par l’utilisateur.
Structure conditionnelle if-else : Les conditions if-else permettent d’exécuter du code différent en fonction d’une condition.
if (age >= 18) : Si la condition age >= 18 est vraie, alors Java exécute le bloc de code à l’intérieur du if.else : Si la condition est fausse, le bloc de code dans le else est exécuté. Dans ce cas, cela signifie que l’utilisateur est mineur.
Affichage du résultat : Selon l’âge fourni par l’utilisateur, le programme affichera soit « Vous êtes majeur. » soit « Vous êtes mineur. ».
forObjectif : Comprendre comment fonctionne la boucle for.
Énoncé : Écrivez un programme qui affiche les nombres de 1 à 10.
public class BoucleFor {
public static void main(String[] args) {
// Boucle qui itère de 1 à 10
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
}
for est utilisée pour répéter une action un nombre déterminé de fois. Elle se compose de trois parties :int i = 1) : La variable i est initialisée à 1. C’est notre compteur, qui débute à 1.i <= 10) : La boucle continue de s’exécuter tant que cette condition est vraie. Ici, elle tourne jusqu’à ce que i atteigne 10.i++) : Après chaque itération, la valeur de i est augmentée de 1 (i++ est une manière raccourcie de dire i = i + 1). Objectif : Apprendre à créer et utiliser des fonctions.
Énoncé : Créez une fonction saluer qui prend un nom en paramètre et affiche "Bonjour, [nom]!". Appelez cette fonction avec plusieurs noms différents.
public class FonctionSaluer {
// Définition de la fonction saluer
public static void saluer(String nom) {
System.out.println("Bonjour, " + nom + "!");
}
public static void main(String[] args) {
// Appel de la fonction avec différents noms
saluer("Alice");
saluer("Bob");
saluer("Charlie");
}
}
Fonction saluer : Une fonction est un bloc de code réutilisable. Elle peut prendre des paramètres (comme ici String nom) et effectuer des actions. La fonction saluer prend un nom en entrée et affiche un message de salutation.
public static void saluer(String nom) :
public : Cette fonction peut être appelée depuis n’importe où dans le programme.static : Cette fonction appartient à la classe FonctionSaluer elle-même, et non à un objet de cette classe. On peut donc l’appeler directement depuis la méthode main.void : La fonction ne retourne aucune valeur.
Appel de la fonction : Dans la méthode main, la fonction saluer est appelée trois fois avec des noms différents. Chaque appel affiche une salutation personnalisée.
Objectif : Comprendre la manipulation des tableaux en Java.
Énoncé : Créez un tableau de trois noms et affichez-les en utilisant une boucle for.
public class Tableaux {
public static void main(String[] args) {
// Définition du tableau
String[] noms = {"Alice", "Bob", "Charlie"};
// Boucle à travers le tableau
for (int i = 0; i < noms.length; i++) {
System.out.println(noms[i]);
}
}
}
Tableau (String[] noms) : Un tableau est une collection d’éléments du même type. Ici, noms est un tableau de chaînes de caractères contenant trois éléments : "Alice", "Bob", et "Charlie".
Accès aux éléments : Les éléments du tableau sont accessibles via leur index, qui commence à 0. Par exemple, noms[0] renvoie "Alice".
Boucle for : La boucle parcourt chaque élément du tableau. La condition i < noms.length assure que la boucle s’exécute pour chaque élément, car noms.length retourne le nombre d’éléments dans le tableau (ici, 3).
Affichage des noms : À chaque itération, noms[i] affiche l’élément du tableau correspondant à l’indice i.
Objectif : Apprendre à créer des classes et des objets en Java.
Énoncé : Créez une classe Personne avec des attributs nom et age. Créez deux objets à partir de cette classe et affichez leurs informations.
public class Personne {
String nom;
int age;
// Constructeur de la classe
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
// Méthode pour afficher les informations de la personne
public void afficherInfo() {
System.out.println("Nom: " + nom);
System.out.println("Âge: " + age);
}
public static void main(String[] args) {
// Création d'objets Personne
Personne p1 = new Personne("Alice", 25);
Personne p2 = new Personne("Bob", 30);
// Affichage des informations des objets
p1.afficherInfo();
p2.afficherInfo();
}
}
Classe Personne : Une classe est un modèle ou un plan à partir duquel des objets sont créés. La classe Personne a deux attributs (nom et age) qui décrivent les propriétés d’une personne.
Constructeur (Personne(String nom, int age)) : Le constructeur est une méthode spéciale utilisée pour initialiser les objets de la classe. Il a le même nom que la classe et ne retourne aucune valeur. Lorsque vous créez une nouvelle Personne, vous passez les valeurs de nom et age au constructeur pour initialiser l’objet.
Méthode afficherInfo : Cette méthode est utilisée pour afficher les informations d’une personne. Elle combine l’affichage du nom et de l’age de l’objet.
Création d’objets : Les objets p1 et p2 sont créés en utilisant le mot-clé new suivi de l’appel au constructeur. Chaque objet représente une personne avec des valeurs spécifiques pour nom et age.
Affichage des informations : En appelant la méthode afficherInfo sur chaque objet, le programme affiche les informations des deux personnes créées.
Objectif : Apprendre à manipuler les collections en Java, notamment les listes (ArrayList), et à effectuer des opérations courantes telles que l’ajout, la suppression, et la recherche d’éléments.
Énoncé : Créez une application Java qui permet à un utilisateur de gérer une liste de noms. Le programme doit permettre d’ajouter un nom, de supprimer un nom, de vérifier si un nom existe dans la liste, et d’afficher tous les noms présents dans la liste.
import java.util.ArrayList;
import java.util.Scanner;
public class GestionListeNoms {
public static void main(String[] args) {
// Création d'une liste pour stocker les noms
ArrayList<String> noms = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
int choix;
do {
// Menu des options disponibles
System.out.println("\n--- Gestion de la Liste de Noms ---");
System.out.println("1. Ajouter un nom");
System.out.println("2. Supprimer un nom");
System.out.println("3. Vérifier si un nom existe");
System.out.println("4. Afficher tous les noms");
System.out.println("5. Quitter");
System.out.print("Choisissez une option : ");
choix = scanner.nextInt();
scanner.nextLine(); // Consomme la nouvelle ligne
switch (choix) {
case 1:
System.out.print("Entrez le nom à ajouter : ");
String nomAjouter = scanner.nextLine();
noms.add(nomAjouter);
System.out.println(nomAjouter + " a été ajouté à la liste.");
break;
case 2:
System.out.print("Entrez le nom à supprimer : ");
String nomSupprimer = scanner.nextLine();
if (noms.remove(nomSupprimer)) {
System.out.println(nomSupprimer + " a été supprimé de la liste.");
} else {
System.out.println(nomSupprimer + " n'existe pas dans la liste.");
}
break;
case 3:
System.out.print("Entrez le nom à vérifier : ");
String nomVerifier = scanner.nextLine();
if (noms.contains(nomVerifier)) {
System.out.println(nomVerifier + " est présent dans la liste.");
} else {
System.out.println(nomVerifier + " n'est pas présent dans la liste.");
}
break;
case 4:
System.out.println("\n--- Liste des Noms ---");
for (String nom : noms) {
System.out.println(nom);
}
break;
case 5:
System.out.println("Sortie du programme.");
break;
default:
System.out.println("Option invalide. Veuillez réessayer.");
}
} while (choix != 5);
}
}
ArrayList (ArrayList<String> noms) : L’objet ArrayList est une collection dynamique qui permet de stocker des éléments, ici des chaînes de caractères (String). Contrairement aux tableaux statiques, une ArrayList peut redimensionner sa capacité automatiquement lorsqu’on y ajoute ou retire des éléments.
Menu d’options : Le programme utilise une boucle do-while pour afficher un menu et traiter les choix de l’utilisateur jusqu’à ce qu’il décide de quitter (option 5). Chaque option correspond à une opération sur la ArrayList.
Ajout de noms (noms.add(nomAjouter)) : L’utilisateur peut ajouter un nom à la liste en le saisissant, et le nom est stocké à la fin de la ArrayList grâce à la méthode add.
Suppression de noms (noms.remove(nomSupprimer)) : Pour supprimer un nom, le programme vérifie d’abord s’il existe dans la liste. Si oui, il est supprimé; sinon, un message d’erreur est affiché.
Vérification d’existence (noms.contains(nomVerifier)) : Cette opération utilise la méthode contains pour vérifier si un nom spécifique est présent dans la liste. La réponse est soit affirmative, soit négative.
Affichage de la liste des noms : La méthode for-each parcourt tous les éléments de la ArrayList et les affiche un par un.
Scanner (Scanner scanner = new Scanner(System.in)) : Le scanner est utilisé pour capturer les entrées de l’utilisateur depuis la console. Chaque saisie de l’utilisateur est ensuite traitée selon l’option choisie.
Objectif : Apprendre à gérer les exceptions en Java.
Énoncé : Écrivez un programme qui demande un nombre à l’utilisateur et tente de diviser 100 par ce nombre. Gérez l’exception si l’utilisateur entre 0.
import java.util.Scanner;
public class GestionExceptions {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre: ");
int nombre = scanner.nextInt();
try {
// Tentative de division
int resultat = 100 / nombre;
System.out.println("Résultat: " + resultat);
} catch (ArithmeticException e) {
// Gestion de l'exception en cas de division par zéro
System.out.println("Erreur : Division par zéro non permise.");
}
}
}
try-catch : Le bloc try contient le code qui peut potentiellement provoquer une exception. Si une exception se produit (comme une division par zéro), elle est capturée par le bloc catch, où une action est définie pour gérer cette exception.
ArithmeticException : Cette exception est levée lorsqu’une opération arithmétique illégale se produit, comme une division par zéro. En la capturant, on évite que le programme ne s’arrête brusquement et on peut afficher un message d’erreur à l’utilisateur.
Gestion des erreurs : La gestion des exceptions permet de créer des programmes robustes qui peuvent anticiper et gérer des erreurs sans planter. Cela est crucial dans les applications du monde réel où les utilisateurs peuvent entrer des données imprévues.
