Java 11 - Nouvelles Fonctionnalités

Bonjour là-bas, aspirants programmeurs Java ! Je suis ravi de vous guider sur ce voyage passionnant dans le monde de Java 11. En tant que quelqu'un qui enseigne l'informatique depuis de nombreuses années, j'ai vu des centaines d'étudiants passer de complets débutants à des codeurs confiants. Alors, ne vous inquiétez pas si vous commencez de zéro - nous allons avancer pas à pas, et avant que vous ne vous en rendiez compte, vous serez en train d'écrire du code Java comme un pro !

Déclarations de Contrôle Java

Commençons par les bases. Les déclarations de contrôle sont comme les feux de circulation du programme - elles dirigent le flux de votre code. En Java 11, nous avons quelques moyens ingénieux pour contrôler l'exécution de notre programme.

Déclarations If-Else

La déclaration if-else est probablement la structure de contrôle la plus courante que vous utiliserez. C'est comme prendre une décision dans la vie réelle. Voici un exemple simple :

int age = 18;
if (age >= 18) {
System.out.println("Vous pouvez voter !");
} else {
System.out.println("Désolé, vous êtes trop jeune pour voter.");
}

Dans ce code, nous vérifions si la variable age est de 18 ans ou plus. Si c'est le cas, nous affichons que la personne peut voter. Sinon, nous lui disons qu'elle est trop jeune. C'est aussi simple que ça !

Déclarations Switch

Les déclarations switch sont géniales lorsque vous avez plusieurs conditions à vérifier. Pensez-y comme une manière plus efficace d'écrire plusieurs déclarations if-else. Java 11 a introduit quelques améliorations sympas aux déclarations switch. Voici un exemple :

String day = "Monday";
switch (day) {
case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> System.out.println("Jour de semaine");
case "Saturday", "Sunday" -> System.out.println("Week-end");
default -> System.out.println("Jour invalide");
}

Cette déclaration switch vérifie la variable day et affiche si c'est un jour de semaine ou un week-end. La syntaxe du flèche (->) est nouvelle en Java 11 et rend le code plus concis.

Programmation Orientée Objet (POO)

La programmation orientée objet (POO) est un concept fondamental en Java. C'est comme construire avec des blocs LEGO - vous créez différents objets qui interagissent les uns avec les autres pour former votre programme.

Classes et Objets

Une classe est comme un plan pour créer des objets. Voici une classe simple représentant une voiture :

public class Car {
String make;
String model;
int year;

public void startEngine() {
System.out.println("Vroom ! La " + year + " " + make + " " + model + " démarre.");
}
}

Maintenant, créons un objet à partir de cette classe :

Car myCar = new Car();
myCar.make = "Toyota";
myCar.model = "Corolla";
myCar.year = 2021;
myCar.startEngine();

Lorsque vous exécutez ce code, il affichera : "Vroom ! La 2021 Toyota Corolla démarre."

Classes Prédéfinies Java

Java vient avec un riche ensemble de classes prédéfinies qui rendent notre vie plus facile. Jetons un coup d'œil à quelques-unes :

Classe String

La classe String est utilisée pour manipuler du texte. Voici un exemple :

String greeting = "Bonjour, Monde !";
System.out.println(greeting.length());  // Affiche : 13
System.out.println(greeting.toUpperCase());  // Affiche : BONJOUR, MONDE !

Classe ArrayList

ArrayList est un tableau dynamique qui peut croître ou se rétrécir selon les besoins :

import java.util.ArrayList;

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
System.out.println(fruits);  // Affiche : [Apple, Banana, Cherry]

Gestion des Fichiers Java

La gestion des fichiers est essentielle pour lire et écrire dans des fichiers. Java 11 a introduit quelques nouvelles méthodes pour rendre cela plus simple :

import java.nio.file.Files;
import java.nio.file.Path;

String content = "Bonjour, Java 11 !";
Path filePath = Path.of("example.txt");
Files.writeString(filePath, content);

String readContent = Files.readString(filePath);
System.out.println(readContent);  // Affiche : Bonjour, Java 11 !

Ce code écrit une chaîne de caractères dans un fichier puis le lit à nouveau. Les méthodes writeString et readString sont nouvelles en Java 11 et rendent l'E/S de fichiers beaucoup plus simple.

Gestion des Erreurs et Exceptions Java

Les erreurs et les exceptions sont comme les bosses et les nids-de-poule sur la route de la programmation. Java nous aide à les gérer avec grâce :

try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Oups ! Vous ne pouvez pas diviser par zéro.");
} finally {
System.out.println("Cela s'exécute toujours, qu'il y ait une erreur ou non.");
}

Ce code tente de diviser par zéro (ce qui est interdit en mathématiques), attrape l'exception résultante et affiche un message amical au lieu de planter.

Multithreading Java

Le multithreading, c'est comme jongler - il permet à votre programme de faire plusieurs choses à la fois. Voici un exemple simple :

class MyThread extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Valeur " + i);
}
}
}

public class Main {
public static void main(String args[]) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
}
}

Cela crée deux threads qui s'exécutent simultanément, chacun affichant son identifiant de thread et une valeur.

Synchronisation Java

Lorsque plusieurs threads accèdent à des ressources partagées, nous devons les synchroniser pour éviter les conflits. C'est comme avoir des feux de circulation à un carrefour :

class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}

Le mot-clé synchronized garantit que seuls un thread à la fois peut exécuter la méthode increment.

Réseau Java

Java rend la création d'applications réseau facile. Voici un serveur simple qui écoute les connexions :

import java.net.*;
import java.io.*;

public class SimpleServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Le serveur écoute sur le port 8080");
Socket socket = serverSocket.accept();
System.out.println("Client connecté");
}
}

Ce serveur écoute sur le port 8080 et affiche un message lorsque un client se connecte.

Collections Java

Les collections Java sont comme différents types de contenants pour stocker des objets. Jetons un coup d'œil à quelques-unes :

List

import java.util.*;

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
System.out.println(fruits);  // Affiche : [Apple, Banana]

Set

Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(1);  // Dupliqué, ne sera pas ajouté
System.out.println(numbers);  // Affiche : [1, 2]

Map

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);
System.out.println(ages.get("Alice"));  // Affiche : 25

Interfaces Java

Les interfaces sont comme des contrats que les classes peuvent accepter de suivre. Voici un exemple :

interface Animal {
void makeSound();
}

class Dog implements Animal {
public void makeSound() {
System.out.println("Wouf !");
}
}

class Cat implements Animal {
public void makeSound() {
System.out.println("Miaou !");
}
}

Les classes Dog et Cat implémentent l'interface Animal, acceptant de fournir une méthode makeSound.

Structures de Données Java

Les structures de données sont des moyens d'organiser et de stocker les données. Jetons un coup d'œil à une liste chaînée simple :

class Node {
int data;
Node next;

Node(int d) { data = d; }
}

class LinkedList {
Node head;

public void add(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
}

public void print() {
Node current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
}

public class Main {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.print();  // Affiche : 1 2 3
}
}

Ce code implémente une structure de données simple liste chaînée.

Algorithmes de Collections Java

Java fournit de nombreux algorithmes utiles pour travailler avec des collections. Voici un exemple de tri :

import java.util.*;

List<Integer> numbers = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5));
Collections.sort(numbers);
System.out.println(numbers);  // Affiche : [1, 1, 2, 3, 4, 5, 5, 6, 9]

Java Avancé

À mesure que vous progressez, vous rencontrerez des concepts plus avancés de Java. Un tel concept est les expressions lambda, introduites en Java 8 et améliorées en Java 11 :

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.forEach(n -> System.out.println(n * 2));

Ce code utilise une expression lambda pour multiplier chaque nombre par 2 et l'afficher.

Java Divers

Java 11 a introduit plusieurs fonctionnalités diverses. L'une d'elles est le mot-clé var pour l'inférence de type de variable locale :

var message = "Bonjour, Java 11 !";
System.out.println(message);

Le compilateur infère que message est une chaîne de caractères.

API et Frameworks Java

Java a un écosystème vastes d'API et de frameworks. Un framework populaire est Spring Boot. Voici un exemple simple d'application "Hello World" Spring Boot :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class HelloWorldApplication {

public static void main(String[] args) {
SpringApplication.run(HelloWorldApplication.class, args);
}

@GetMapping("/")
public String hello() {
return "Bonjour, Monde !";
}
}

Cela crée une application web qui répond avec "Bonjour, Monde !" lorsque vous visitez l'URL racine.

Références de Classes Java

Java vous permet d'obtenir des références aux classes à l'exécution. Voici un exemple :

Class<?> stringClass = String.class;
System.out.println(stringClass.getName());  // Affiche : java.lang.String

Ressources Utiles pour Apprendre Java

Voici quelques ressources utiles pour apprendre Java :

1. Documentation officielle d'Oracle sur Java
2. Le cours de Java sur Codecademy
3. Le livre "Head First Java"
4. Stack Overflow pour poser des questions

Nouvelles Fonctionnalités

Java 11 a introduit plusieurs nouvelles fonctionnalités. Voici un tableau résumant quelques-unes d'entre elles :

Fonctionnalité	Description
Syntaxe Locale pour Lambda Parameters	Permet var dans les expressions lambda
HTTP Client (Standard)	API client HTTP standardisée
Lancement de Programmes Source Unique	Exécuter directement des fichiers source Java
Méthodes de Chaîne	Nouvelles méthodes comme isBlank(), lines(), strip(), etc.
Méthodes de Fichiers	Nouvelles méthodes comme readString(), writeString()

Voilà pour notre tour d'horizon rapide de Java 11 ! Souvenez-vous, apprendre à coder, c'est comme apprendre une nouvelle langue - cela prend de la pratique, de la patience et de la persévérance. Ne soyez pas découragé si vous ne comprenez pas tout de suite. Continuez à coder, continuez à expérimenter, et surtout, continuez à vous amuser ! Avant que vous ne vous en rendiez compte, vous serez en train d'écrire des applications Java complexes et vous vous demanderez comment elles vous semblaient si difficiles au début. Bon codage !

Credits: Image by storyset