Close
Java a été créé par Sun Microsystems (maintenant Oracle) en 1995. C’est un langage de programmation polyvalent qui peut être utilisé pour développer une grande variété d’applications. Java est connu pour son principe « Write Once, Run Anywhere » (WORA), ce qui signifie que le code Java peut fonctionner sur toute machine dotée d’une machine virtuelle Java (JVM).
Avant de commencer à coder en Java, vous devez installer le JDK (Java Development Kit), qui comprend le compilateur javac et la JVM (Java Virtual Machine). Vous pouvez télécharger le JDK à partir du site officiel d’Oracle.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
public class HelloWorld : Cela déclare une classe publique nommée HelloWorld. En Java, tout code doit être encapsulé dans une classe.public static void main(String[] args) : C’est la méthode principale qui est le point d’entrée de tout programme Java. public signifie que la méthode est accessible de partout, static signifie qu’elle appartient à la classe plutôt qu’à une instance, void signifie qu’elle ne retourne aucune valeur, et String[] args est un tableau d’arguments passés en ligne de commande.System.out.println("Hello, World!"); : Cette ligne affiche « Hello, World! » dans la console. System.out est un flux de sortie standard et println est une méthode qui imprime la ligne de texte.
En Java, chaque variable doit être déclarée avec un type de données spécifique. Voici les principaux types de données en Java :
int age = 30; // Entier
double salaire = 4500.50; // Nombre à virgule flottante
char lettre = 'A'; // Caractère unique
boolean estVrai = true; // Booléen (vrai ou faux)
String nom = "Alice"; // Chaîne de caractères
int : Type pour les entiers.double : Type pour les nombres à virgule flottante.char : Type pour les caractères simples (en utilisant des guillemets simples).boolean : Type pour les valeurs booléennes (vrai ou faux).String : Type pour les chaînes de caractères (en utilisant des guillemets doubles).
Java prend en charge les opérations arithmétiques, logiques et relationnelles de base.
int a = 5;
int b = 3;
int somme = a + b; // Addition
int difference = a - b; // Soustraction
int produit = a * b; // Multiplication
int quotient = a / b; // Division
int reste = a % b; // Modulo
boolean estEgal = (a == b); // Égalité
boolean estDifferent = (a != b); // Différence
boolean estSuperieur = (a > b); // Supérieur
boolean estInferieur = (a < b); // Inférieur
+, -, *, /, % sont les opérateurs pour l’addition, soustraction, multiplication, division et modulo.==, !=, >, < sont utilisés pour comparer deux valeurs.
if, else if, else)Les conditions permettent d’exécuter du code en fonction de certaines conditions.
int age = 18;
if (age >= 18) {
System.out.println("Vous êtes majeur.");
} else if (age >= 13) {
System.out.println("Vous êtes adolescent.");
} else {
System.out.println("Vous êtes mineur.");
}
if : Vérifie si la condition est vraie. Si oui, exécute le bloc de code associé.else if : Fournit une condition alternative si la première est fausse.else : Exécute du code si aucune des conditions précédentes n’est vraie.
forfor (int i = 0; i < 5; i++) {
System.out.println("i est égal à " + i);
}
for : La boucle for est utilisée lorsque vous savez à l’avance combien de fois vous voulez exécuter un bloc de code. int i = 0; initialise la variable i, i < 5 est la condition de boucle, et i++ incrémente i après chaque itération.whileint i = 0;
while (i < 5) {
System.out.println("i est égal à " + i);
i++;
}
while : La boucle while exécute le bloc de code tant que la condition est vraie. Ici, la boucle continue tant que i est inférieur à 5.do-whileint i = 0;
do {
System.out.println("i est égal à " + i);
i++;
} while (i < 5);
do-while : Cette boucle exécute le bloc de code au moins une fois, puis continue de l’exécuter tant que la condition est vraie. Les méthodes sont des blocs de code réutilisables qui effectuent une tâche spécifique.
public class Calculatrice {
public int addition(int a, int b) {
return a + b;
}
public static void main(String[] args) {
Calculatrice calc = new Calculatrice();
int resultat = calc.addition(5, 3);
System.out.println("Le résultat est : " + resultat);
}
}
public int addition(int a, int b) : Déclare une méthode publique addition qui prend deux paramètres a et b de type int et retourne la somme de a et b.return a + b; : Retourne le résultat de l’addition.main : Le point d’entrée du programme. Un objet Calculatrice est créé pour appeler la méthode addition. La POO est un paradigme de programmation qui utilise des « objets », lesquels sont des instances de « classes ». Java est fortement orienté objet, et comprendre la POO est essentiel pour maîtriser Java.
public class Personne {
// Attributs
String nom;
int age;
// Constructeur
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
// Méthode
public void afficherDetails() {
System.out.println("Nom: " + nom + ", Age: " + age);
}
public static void main(String[] args) {
// Création d'un objet
Personne personne1 = new Personne("Alice", 30);
personne1.afficherDetails();
}
}
Personne : Définit un modèle pour les objets Personne avec des attributs nom et age.this.nom = nom; : this fait référence à l’instance actuelle de la classe. Cela différencie l’attribut de l’argument du constructeur.afficherDetails : Affiche les détails de la personne.Personne : personne1 est une instance de la classe Personne créée avec le constructeur.
L’héritage permet à une classe de hériter des attributs et des méthodes d’une autre classe.
// Classe Parent
public class Animal {
public void manger() {
System.out.println("L'animal mange.");
}
}
// Classe Enfant
public class Chien extends Animal {
public void aboyer() {
System.out.println("Le chien aboie.");
}
public static void main(String[] args) {
Chien chien = new Chien();
chien.manger(); // Hérité de Animal
chien.aboyer(); // Défini dans Chien
}
}
Animal : Classe parent avec une méthode manger.Chien : Classe enfant qui hérite de Animal avec la méthode manger et définit une méthode supplémentaire aboyer.chien.manger(); : Appelle la méthode manger héritée de Animal.
Le polymorphisme permet d’utiliser une méthode de différentes manières selon l’objet sur lequel elle est appelée.
public class Animal {
public void faireDuBruit() {
System.out.println("L'animal fait du bruit.");
}
}
public class Chat extends Animal {
public void faireDuBruit() {
System.out.println("Le chat miaule.");
}
}
public class Chien extends Animal {
public void faireDuBruit() {
System.out.println("Le chien aboie.");
}
public static void main(String[] args) {
Animal monAnimal = new Animal();
Animal monChat = new Chat();
Animal monChien = new Chien();
monAnimal.faireDuBruit(); // L'animal fait du bruit.
monChat.faireDuBruit(); // Le chat miaule.
monChien.faireDuBruit(); // Le chien aboie.
}
}
faireDuBruit : Cette méthode est définie dans Animal, mais est redéfinie dans Chat et Chien.faireDuBruit dépend du type réel de l’objet (ici, Chat ou Chien), même si la référence est de type Animal. Les exceptions sont des événements qui perturbent le flux normal du programme. Java permet de gérer ces exceptions en utilisant try, catch, et finally.
public class GestionException {
public static void main(String[] args) {
try {
int division = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Erreur : Division par zéro.");
} finally {
System.out.println("Bloc finally exécuté.");
}
}
}
try : Enveloppe le code qui peut potentiellement générer une exception.catch : Intercepte l’exception et exécute le code pour la gérer.finally : Exécute un bloc de code, qu’une exception soit levée ou non. Vous avez maintenant un aperçu complet des concepts fondamentaux de Java, y compris la structure de base, les variables, les structures de contrôle, la programmation orientée objet, et la gestion des exceptions. Java est un langage puissant et polyvalent, et maîtriser ces concepts vous permettra de développer des applications robustes et évolutives.
Pour approfondir vos connaissances en Java, voici quelques ressources recommandées :
