### Question 1 : Quelle est la sortie de ce code ?

```java
public class Main {
public static void main(String[] args) {
int x = 10;
int y = 20;
System.out.println(x + y + " " + x * y);
}
}
```

**Réponse :** La sortie sera `30 200` car l'addition est effectuée avant la multiplication
dans la chaîne de caractères.

### Question 2 : Qu'est-ce que l'encapsulation en Java ?

**Réponse :** L'encapsulation est un principe de la programmation orientée objet qui

consiste à restreindre l'accès direct aux données d'un objet et à fournir des méthodes
pour accéder et modifier ces données. Cela se fait généralement en déclarant les
variables comme privées et en fournissant des méthodes publiques pour y accéder et
les modifier.

### Question 3 : Quelle est la différence entre `ArrayList` et `LinkedList` ?

**Réponse :** `ArrayList` est basé sur un tableau dynamique et offre un accès rapide
aux éléments par index, tandis que `LinkedList` utilise une liste doublement chaînée et
est plus performant pour les opérations d'insertion et de suppression.

### Question 4 : Comment créer une exception personnalisée ?

**Réponse :**
```java
public class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}

public class Main {

public static void main(String[] args) {
try {
throw new CustomException("Ceci est une exception personnalisée");
} catch (CustomException e) {
System.out.println(e.getMessage());
}
}
}
```

### Question 5 : Qu'est-ce qu'une classe anonyme en Java ?

**Réponse :** Une classe anonyme est une classe sans nom qui est définie au moment
de l'instanciation d'un objet. Elle est souvent utilisée pour implémenter des interfaces ou
des classes abstraites sur le champ.

### Question 6 : Comment fonctionne le ramasse-miettes (garbage collector) en Java ?

**Réponse :** Le ramasse-miettes est un processus automatique en Java qui libère la

mémoire en supprimant les objets qui ne sont plus utilisés par le programme. Cela aide
à gérer la mémoire et à éviter les fuites de mémoire.

### Question 7 : Qu'est-ce que le mot-clé `static` ?

**Réponse :** Le mot-clé `static` indique qu'un membre appartient à la classe plutôt
qu'à une instance spécifique de la classe. Les membres `static` peuvent être accédés
sans créer une instance de la classe.

### Question 8 : Comment déclarer et utiliser une interface en Java ?

**Réponse :**
```java
interface Drawable {
void draw();
}

class Circle implements Drawable {

public void draw() {
System.out.println("Dessin du cercle");
}
}

public class Main {

public static void main(String[] args) {
Drawable d = new Circle();
d.draw();
}
}
```

### Question 9 : Qu'est-ce qu'une `HashSet` et comment est-elle différente d'une

`TreeSet` ?
**Réponse :** `HashSet` est une collection qui ne permet pas les doublons et ne
garantit pas l'ordre des éléments. `TreeSet` est une collection qui ne permet pas les
doublons mais maintient les éléments dans un ordre trié naturel ou défini par un
comparateur.

### Question 10 : Qu'est-ce qu'une méthode `abstract` ?

**Réponse :** Une méthode `abstract` est une méthode qui n'a pas d'implémentation
dans la classe où elle est déclarée. Les sous-classes doivent fournir une
implémentation concrète de cette méthode.

### Question 11 : Quelle est la différence entre `StringBuilder` et `StringBuffer` ?

**Réponse :** `StringBuilder` est plus rapide que `StringBuffer` car il n'est pas
synchronisé. `StringBuffer` est synchronisé et donc thread-safe, ce qui le rend plus sûr
pour une utilisation dans des environnements multithreadés.

### Question 12 : Qu'est-ce que le polymorphisme en Java ?

**Réponse :** Le polymorphisme permet à une méthode de se comporter différemment

selon le type d'objet qui l'appelle. Il peut être réalisé via la surcharge de méthode
(overloading) et la redéfinition de méthode (overriding).

### Question 13 : Comment implémenter une méthode de tri personnalisée avec

`Collections.sort()` ?

**Réponse :**
```java
import java.util.*;

public class CustomSort {

public static void main(String[] args) {
List<String> list = Arrays.asList("Banana", "Apple", "Orange");
Collections.sort(list, new Comparator<String>() {
public int compare(String s1, String s2) {
return s1.length() - s2.length(); // Tri par longueur
}
});
System.out.println(list);
}
}
```

### Question 14 : Qu'est-ce que l'overloading et l'overriding des méthodes ?

**Réponse :** L'overloading (surcharge) permet de définir plusieurs méthodes avec le
même nom mais des paramètres différents dans une même classe. L'overriding
(redéfinition) permet à une sous-classe de fournir une implémentation spécifique d'une
méthode déjà définie dans sa classe de base.

### Question 15 : Comment utiliser les flux de données (streams) en Java 8 ?

**Réponse :**
```java
import java.util.Arrays;
import java.util.List;

public class StreamExample {

public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream()
.filter(s -> s.startsWith("b"))
.forEach(System.out::println);
}
}
```

### Question 16 : Comment implémenter une méthode statique dans une interface ?

**Réponse :**
```java
interface MyInterface {
static void staticMethod() {
System.out.println("Méthode statique de l'interface");
}
}

public class Main {

public static void main(String[] args) {
MyInterface.staticMethod();
}
}
```

### Question 17 : Qu'est-ce qu'une `Optional` et comment est-elle utilisée ?

**Réponse :**
```java
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
Optional<String> optional = Optional.of("Hello");
optional.ifPresent(System.out::println);
}
}
```

### Question 18 : Quelle est la différence entre une interface fonctionnelle et une
interface normale ?

**Réponse :** Une interface fonctionnelle est une interface qui ne contient qu'une seule
méthode abstraite, ce qui permet de l'utiliser avec des expressions lambda. Les
interfaces normales peuvent avoir plusieurs méthodes abstraites.

Ces questions couvrent des aspects variés de Java, allant des concepts fondamentaux
aux fonctionnalités plus avancées. Elles devraient offrir un bon éventail de révision.

### Question 19 : Inverser une chaîne de caractères

**Q :** Écrivez un programme Java pour inverser une chaîne de caractères donnée.

**R :**
```java
public class ReverseString {
public static void main(String[] args) {
String original = "Java";
String reversed = new StringBuilder(original).reverse().toString();
System.out.println("Chaîne inversée : " + reversed);
}
}
```

### Question 20 : Trouver la valeur maximale dans un tableau

**Q :** Écrivez un programme Java pour trouver la valeur maximale dans un tableau
d'entiers.

**R :**
```java
public class MaxValueArray {
public static void main(String[] args) {
int[] numbers = {3, 5, 7, 2, 8, 10, 4};
int max = numbers[0];
 for (int number : numbers) {
if (number > max) {
max = number;
}
}

System.out.println("La valeur maximale est : " + max);

}
}
```

### Question 21 : Vérifier si une chaîne est un palindrome

**Q :** Écrivez un programme Java pour vérifier si une chaîne est un palindrome.

**R :**
```java
public class PalindromeCheck {
public static void main(String[] args) {
String str = "radar";
String reversed = new StringBuilder(str).reverse().toString();

if (str.equals(reversed)) {
System.out.println(str + " est un palindrome.");
} else {
System.out.println(str + " n'est pas un palindrome.");
}
}
}
```

### Question 22 : Compter le nombre d'occurrences d'un caractère dans une chaîne

**Q :** Écrivez un programme Java pour compter le nombre d'occurrences d'un
caractère dans une chaîne donnée.

**R :**
```java
public class CountCharacter {
public static void main(String[] args) {
String str = "programming";
char charToCount = 'g';
int count = 0;

for (char c : str.toCharArray()) {

 if (c == charToCount) {
count++;
}
}

System.out.println("Le caractère '" + charToCount + "' apparaît " + count + " fois.");
}
}
```

### Question 23 : Trouver la somme des éléments d'un tableau

**Q :** Écrivez un programme Java pour calculer la somme des éléments d'un tableau
d'entiers.

**R :**
```java
public class SumArray {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
int sum = 0;

for (int number : numbers) {

sum += number;
}

System.out.println("La somme des éléments du tableau est : " + sum);

}
}
```

### Question 24 : Vérifier si un nombre est premier

**Q :** Écrivez un programme Java pour vérifier si un nombre est premier.

**R :**
```java
public class PrimeNumberCheck {
public static void main(String[] args) {
int number = 29;
boolean isPrime = true;

if (number <= 1) {
isPrime = false;
} else {
for (int i = 2; i <= Math.sqrt(number); i++) {
 if (number % i == 0) {
isPrime = false;
break;
}
}
}

System.out.println(number + (isPrime ? " est un nombre premier." : " n'est pas un

nombre premier."));
}
}
```

### Question 25 : Générer les premiers n nombres de la suite de Fibonacci

**Q :** Écrivez un programme Java pour générer les premiers `n` nombres de la suite
de Fibonacci.

**R :**
```java
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10;
int a = 0, b = 1;

System.out.print("Suite de Fibonacci : " + a + ", " + b);

for (int i = 2; i < n; i++) {

int next = a + b;
System.out.print(", " + next);
a = b;
b = next;
}
}
}
```

### Question 26 : Convertir une chaîne en majuscules

**Q :** Écrivez un programme Java pour convertir une chaîne en majuscules.

**R :**
```java
public class ToUpperCase {
public static void main(String[] args) {
String str = "hello world";
 String upperStr = str.toUpperCase();
System.out.println("Chaîne en majuscules : " + upperStr);
}
}
```

### Question 27 : Calculer le produit des éléments d'un tableau

**Q :** Écrivez un programme Java pour calculer le produit des éléments d'un tableau
d'entiers.

**R :**
```java
public class ProductArray {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4};
int product = 1;

for (int number : numbers) {

product *= number;
}

System.out.println("Le produit des éléments du tableau est : " + product);

}
}
```

### Question 28 : Afficher les nombres de 1 à 100 qui sont divisibles par 3 et 5

**Q :** Écrivez un programme Java pour afficher les nombres de 1 à 100 qui sont
divisibles par 3 et 5.

**R :**
```java
public class DivisibleByThreeAndFive {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 5 == 0) {
System.out.println(i);
}
}
}
}
```
### Question 29 : Calculer la somme des nombres de 1 à 10

**Énoncé :** Écrivez un programme Java qui calcule et affiche la somme des nombres
de 1 à 10.

**Solution :**
```java
public class SumNumbers {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
System.out.println("La somme des nombres de 1 à 10 est : " + sum);
}
}
```

### Question 30 : Vérifier si un nombre est pair ou impair

**Énoncé :** Écrivez un programme Java qui vérifie si un nombre donné est pair ou
impair.

**Solution :**
```java
import java.util.Scanner;

public class EvenOdd {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre : ");
int number = scanner.nextInt();

if (number % 2 == 0) {
System.out.println(number + " est pair.");
} else {
System.out.println(number + " est impair.");
}
}
}
```

### Question 31 : Trouver le plus grand nombre parmi trois nombres

**Énoncé :** Écrivez un programme Java qui trouve et affiche le plus grand nombre
parmi trois nombres donnés.
**Solution :**
```java
import java.util.Scanner;

public class FindLargest {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez le premier nombre : ");
int num1 = scanner.nextInt();
System.out.print("Entrez le deuxième nombre : ");
int num2 = scanner.nextInt();
System.out.print("Entrez le troisième nombre : ");
int num3 = scanner.nextInt();

int largest = num1;

if (num2 > largest) {

largest = num2;
}
if (num3 > largest) {
largest = num3;
}

System.out.println("Le plus grand nombre est : " + largest);

}
}
```

### Question 32 : Calculer la factorielle d'un nombre

**Énoncé :** Écrivez un programme Java qui calcule la factorielle d'un nombre entier
positif donné.

**Solution :**
```java
import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre entier positif : ");
int number = scanner.nextInt();

int factorial = 1;
for (int i = 1; i <= number; i++) {
 factorial *= i;
}

System.out.println("La factorielle de " + number + " est : " + factorial);

}
}
```

### Question 33 : Afficher une table de multiplication

**Énoncé :** Écrivez un programme Java qui affiche la table de multiplication d'un
nombre donné.

**Solution :**
```java
import java.util.Scanner;

public class MultiplicationTable {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre pour afficher sa table de multiplication : ");
int number = scanner.nextInt();

System.out.println("Table de multiplication de " + number + " :");

for (int i = 1; i <= 10; i++) {
System.out.println(number + " x " + i + " = " + (number * i));
}
}
}
```

1. **Qu'est-ce que Java ?**

- Java est un langage de programmation orienté objet, concurrent et indépendant de
la plateforme, développé par Sun Microsystems (maintenant Oracle).

2. **Quels sont les principaux avantages de Java ?**

- Portabilité, sécurité, gestion automatique de la mémoire (ramasse-miettes), et une
vaste bibliothèque standard.

3. **Comment déclarer une variable en Java ?**

- `type nomVariable;`
- Exemple : `int age;`

4. **Qu'est-ce qu'une classe en Java ?**

 - Une classe est un modèle pour créer des objets. Elle définit les attributs et les
méthodes que les objets créés à partir de cette classe posséderont.

5. **Comment créer une instance d'une classe ?**

- `NomClasse objet = new NomClasse();`
- Exemple : `Personne p = new Personne();`

6. **Qu'est-ce qu'un constructeur en Java ?**

- Un constructeur est une méthode spéciale utilisée pour initialiser les objets lors de
leur création.

7. **Qu'est-ce que l'héritage en Java ?**

- L'héritage est un mécanisme qui permet à une nouvelle classe de dériver des
caractéristiques d'une classe existante.

8. **Comment déclarer une classe qui hérite d'une autre classe ?**
- `class SousClasse extends SuperClasse { }`
- Exemple : `class Employe extends Personne { }`

9. **Qu'est-ce qu'une interface en Java ?**

- Une interface est un contrat que les classes peuvent implémenter, définissant des
méthodes sans fournir leur implémentation.

10. **Comment une classe implémente une interface ?**

- `class NomClasse implements NomInterface { }`
- Exemple : `class Voiture implements Vehicule { }`

11. **Quelle est la différence entre une classe abstraite et une interface ?**
- Une classe abstraite peut avoir des méthodes avec ou sans implémentation, tandis
qu'une interface ne peut avoir que des méthodes sans implémentation (depuis Java 8,
les interfaces peuvent avoir des méthodes par défaut).

12. **Qu'est-ce que le polymorphisme en Java ?**

- Le polymorphisme permet à une méthode d'avoir plusieurs formes, généralement
en surchargant ou en redéfinissant une méthode dans des classes différentes.

13. **Comment redéfinir une méthode dans une sous-classe ?**

- En utilisant le mot-clé `@Override` avant la méthode dans la sous-classe.
- Exemple :
```java
@Override
void afficher() {
// nouvelle implémentation
}
```
14. **Qu'est-ce que la surcharge de méthode ?**
- La surcharge de méthode permet de définir plusieurs méthodes avec le même nom
mais des paramètres différents dans la même classe.

15. **Qu'est-ce que le mot-clé `super` en Java ?**

- `super` fait référence à la classe parente et permet d'accéder aux membres de la
classe parente.

16. **Comment gérer les exceptions en Java ?**

- En utilisant des blocs `try`, `catch`, `finally`, et `throw`.

17. **Qu'est-ce que `try-catch-finally` ?**

- `try` est utilisé pour contenir le code qui peut lancer une exception, `catch` pour
attraper et gérer l'exception, et `finally` pour exécuter du code, qu'une exception soit
lancée ou non.

18. **Qu'est-ce qu'une exception vérifiée ?**

- Une exception vérifiée est une exception que le compilateur oblige à gérer, par
exemple `IOException`.

19. **Qu'est-ce qu'une exception non vérifiée ?**

- Une exception non vérifiée est une exception qui ne nécessite pas d'être déclarée
ou capturée, comme `RuntimeException`.

20. **Qu'est-ce que le ramasse-miettes (garbage collector) en Java ?**

- Le ramasse-miettes est un processus automatique qui gère la libération de la
mémoire en supprimant les objets qui ne sont plus utilisés.

21. **Qu'est-ce que `public`, `private`, et `protected` en Java ?**

- Ce sont des modificateurs d'accès qui contrôlent la visibilité des membres d'une
classe :
- `public` : accessible de partout.
- `private` : accessible uniquement dans la même classe.
- `protected` : accessible dans la même classe, les sous-classes et les classes du
même package.

22. **Qu'est-ce que la méthode `main` en Java ?**

- La méthode `main` est le point d'entrée de tout programme Java. Sa signature est :
`public static void main(String[] args)`.

23. **Comment déclarer un tableau en Java ?**

- `type[] nomTableau;`
- Exemple : `int[] nombres;`

24. **Comment initialiser un tableau en Java ?**

- `type[] nomTableau = new type[taille];`
 - Exemple : `int[] nombres = new int[10];`

25. **Comment parcourir un tableau en Java ?**

- Utilisez une boucle `for` ou une boucle `foreach`.
- Exemple :
```java
for (int i = 0; i < tableau.length; i++) {
System.out.println(tableau[i]);
}
```

26. **Qu'est-ce qu'une collection en Java ?**

- Les collections sont des structures de données qui stockent des objets, comme
`ArrayList`, `HashSet`, etc.

27. **Quelle est la différence entre `ArrayList` et `LinkedList` ?**

- `ArrayList` est basé sur un tableau dynamique et offre des accès rapides par index,
tandis que `LinkedList` est basé sur une liste chaînée et est plus efficace pour les
insertions/suppressions.

28. **Comment ajouter un élément à une `ArrayList` ?**

- `arrayList.add(element);`
- Exemple : `arrayList.add("Bonjour");`

29. **Qu'est-ce que le mot-clé `this` en Java ?**

- `this` fait référence à l'objet courant, c'est-à-dire l'instance actuelle de la classe.

30. **Qu'est-ce qu'une méthode statique en Java ?**

- Une méthode statique appartient à la classe plutôt qu'à une instance spécifique.
Elle est déclarée avec le mot-clé `static`.

31. **Comment déclarer une méthode statique ?**

- `static type nomMethode() { }`
- Exemple : `static void afficherMessage() { }`

32. **Qu'est-ce qu'une méthode abstraite ?**

- Une méthode abstraite est une méthode déclarée dans une classe abstraite sans
implémentation. Les sous-classes doivent fournir une implémentation.

33. **Qu'est-ce qu'une classe interne en Java ?**

- Une classe interne est une classe définie à l'intérieur d'une autre classe. Elle peut
être une classe interne statique ou non statique.

34. **Qu'est-ce qu'une classe anonyme en Java ?**

 - Une classe anonyme est une classe sans nom créée et instanciée en une seule
ligne, souvent utilisée pour les implémentations rapides d'interfaces ou de classes
abstraites.

35. **Comment déclarer un `enum` en Java ?**

- `enum NomEnum { VALEUR1, VALEUR2, VALEUR3 }`
- Exemple : `enum Jour { LUNDI, MARDI, MERCREDI }`

36. **Qu'est-ce que le polymorphisme paramétrique en Java ?**

- Le polymorphisme paramétrique permet de créer des classes, interfaces et
méthodes qui fonctionnent avec des types génériques, à l'aide des génériques (`<>`).

37. **Comment créer une méthode générique ?**

- `public <T> void maMethode(T param) { }`
- Exemple : `public <E> void afficher(E element) { }`

38. **Quelle est la différence entre `==` et `equals()` en Java ?**

- `==` compare les références d'objet (si les deux objets sont identiques en mémoire),
tandis que `equals()` compare le contenu des objets.

39. **Comment faire une copie profonde d'un objet en Java ?**
- Utilisez la sérialisation pour créer une copie profonde ou implémentez la méthode
`clone()` correctement avec l'interface `Cloneable`.

40. **Qu'est-ce que le mot-clé `final` en Java ?**

- `final` peut être utilisé pour déclarer une variable dont la valeur ne peut pas être
modifiée, une méthode qui ne peut pas être redéfinie, ou une classe qui ne peut pas
être héritée.

41. **Comment gérer les entrées et sorties en Java ?**

- Utilisez les classes des packages `java.io` et `java.nio.file`, comme
`FileInputStream`, `FileOutputStream`, et `BufferedReader`.

42. **Qu'est-ce que le multithreading en Java ?**

- Le multithreading est une technique qui permet d'exécuter plusieurs threads (lignes
d'exécution) simultanément.

43. **Comment créer un thread en Java ?**

- En implémentant l'interface `Runnable` ou en étendant la classe `Thread`, puis en
appelant la méthode `start()`.

44. **Qu'est-ce qu'une `Runnable` en Java ?**

44. **Qu'est-ce qu'une `Runnable` en Java ?**
- `Runnable` est une interface fonctionnelle qui représente une tâche qui peut être
exécutée par un thread. Vous implémentez la méthode `run()` pour définir le code à
exécuter dans le thread.

45. **Comment synchroniser l'accès à une ressource partagée entre plusieurs

threads ?**
- Utilisez le mot-clé `synchronized` pour créer des blocs ou des méthodes
synchronisées qui garantissent qu'une seule thread accède à la ressource partagée à la
fois.

46. **Qu'est-ce qu'une exception personnalisée ?**

- Une exception personnalisée est une classe qui étend `Exception` ou
`RuntimeException`, permettant de créer des exceptions spécifiques à votre application.

47. **Comment déclarer une exception personnalisée ?**

- `public class MonException extends Exception { }`

48. **Qu'est-ce que le `try-with-resources` en Java ?**

- `try-with-resources` est une fonctionnalité introduite dans Java 7 pour gérer les
ressources de manière plus efficace en s'assurant qu'elles sont fermées
automatiquement après utilisation.

49. **Comment utiliser le `try-with-resources` ?**

- `try (ResourceType resource = new ResourceType()) { // code }`
- Exemple :
```java
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
// Utilisation de br
} catch (IOException e) {
e.printStackTrace();
}
```

50. **Qu'est-ce qu'une `Stream` en Java ?**

- `Stream` est une abstraction pour travailler avec des séquences de données de
manière fonctionnelle, permettant des opérations comme le filtrage, la transformation et
la réduction.
1. **Qu'est-ce que Java ?**
- Java est un langage de programmation orienté objet, indépendant de la plateforme,
développé par Sun Microsystems (maintenant Oracle).

2. **Quel est l’objectif principal de la machine virtuelle Java (JVM) ?**

- La JVM exécute des programmes Java en convertissant les bytecodes Java en
instructions machine spécifiques à la plateforme.

3. **Quelle est la signature d’une méthode `main` en Java ?**

- `public static void main(String[] args)`

4. **Comment déclarer une variable en Java ?**

- `type nomVariable;`
- Exemple : `int age;`

5. **Quelle est la différence entre les types primitifs et les objets en Java ?**
- Les types primitifs (comme `int`, `char`, `boolean`) sont des valeurs de base, tandis
que les objets sont des instances de classes et ont des attributs et des méthodes.

6. **Comment créer une instance d’une classe en Java ?**

- `NomClasse objet = new NomClasse();`
- Exemple : `Personne p = new Personne();`

7. **Qu’est-ce qu’un constructeur en Java ?**

- Un constructeur est une méthode spéciale utilisée pour initialiser un objet lors de sa
création.

8. **Comment définir un constructeur dans une classe ?**

- `public NomClasse() { // initialisation }`
- Exemple :
```java
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
```

9. **Quelle est la différence entre `public`, `private` et `protected` ?**

- `public` : accessible de partout.
- `private` : accessible uniquement dans la même classe.
- `protected` : accessible dans la même classe, les sous-classes et les classes du
même package.

10. **Qu’est-ce que l’encapsulation en Java ?**

 - L'encapsulation est le principe de regrouper les données et les méthodes qui
manipulent ces données dans une seule unité, la classe, et de restreindre l'accès direct
aux données.

11. **Comment déclarer une méthode en Java ?**

- `modificateurDeAcces typeRetour nomMethode(parametres) { // corps de la
méthode }`
- Exemple : `public void afficher() { System.out.println("Bonjour"); }`

12. **Qu’est-ce que l’héritage en Java ?**

- L'héritage permet à une classe (sous-classe) de dériver les attributs et méthodes
d'une autre classe (super-classe).

13. **Comment une classe hérite-t-elle d'une autre classe ?**

- `class SousClasse extends SuperClasse { }`
- Exemple : `class Employe extends Personne { }`

14. **Qu’est-ce que le polymorphisme en Java ?**

- Le polymorphisme permet à des méthodes d’avoir plusieurs formes. Il se manifeste
principalement par la surcharge et la redéfinition de méthodes.

15. **Qu’est-ce que la surcharge de méthodes ?**

- La surcharge permet d’avoir plusieurs méthodes avec le même nom mais des
signatures différentes (paramètres différents) dans une même classe.

16. **Qu’est-ce que la redéfinition de méthodes (override) ?**

- La redéfinition permet à une sous-classe de fournir une nouvelle implémentation
pour une méthode déjà définie dans sa super-classe.

17. **Qu’est-ce qu’une interface en Java ?**

- Une interface est un contrat qui définit des méthodes que les classes doivent
implémenter.

18. **Comment déclarer une interface ?**

- `public interface NomInterface { // méthodes abstraites }`
- Exemple :
```java
public interface Vehicule {
void conduire();
}
```

19. **Comment une classe implémente une interface ?**

- `class NomClasse implements NomInterface { // implémentation des méthodes }`
- Exemple :
```java
 public class Voiture implements Vehicule {
public void conduire() {
System.out.println("Conduire une voiture");
}
}
```

20. **Qu’est-ce qu’une classe abstraite ?**

- Une classe abstraite est une classe qui ne peut pas être instanciée directement et
peut contenir des méthodes abstraites (sans implémentation).

21. **Comment déclarer une classe abstraite ?**

- `public abstract class NomClasse { // méthodes abstraites et non abstraites }`
- Exemple :
```java
public abstract class Animal {
public abstract void faireDuBruit();
}
```

22. **Qu’est-ce que le mot-clé `final` en Java ?**

- `final` est utilisé pour déclarer des variables constantes, des méthodes non
modifiables, et des classes non extensibles.

23. **Comment déclarer une variable constante en Java ?**

- `public static final type NOM_VARIABLE = valeur;`
- Exemple : `public static final int MAX_AGE = 120;`

24. **Qu’est-ce qu’une exception en Java ?**

- Une exception est un événement qui se produit pendant l'exécution d'un
programme et qui interrompt son flux normal.

25. **Comment gérer les exceptions en Java ?**

- Utilisez les blocs `try`, `catch`, `finally`, et `throw`.

26. **Qu’est-ce qu’un bloc `try-catch` ?**

- `try` contient le code susceptible de lancer une exception, et `catch` capture et gère
l’exception.

27. **Comment déclarer une méthode qui lance une exception ?**
- `public void maMethode() throws ExceptionType { // code }`
- Exemple : `public void lireFichier() throws IOException { }`

28. **Qu’est-ce que le ramasse-miettes (garbage collector) ?**

- Le ramasse-miettes gère la libération de la mémoire en supprimant les objets non
utilisés.
29. **Comment créer et manipuler un tableau en Java ?**
- Déclaration : `type[] nomTableau;`
- Initialisation : `nomTableau = new type[taille];`
- Exemple : `int[] nombres = new int[10];`

30. **Quelle est la différence entre `ArrayList` et `LinkedList` ?**

- `ArrayList` utilise un tableau dynamique, offrant un accès rapide par index, tandis
que `LinkedList` utilise une liste chaînée, ce qui est plus efficace pour les insertions et
suppressions.

31. **Comment ajouter un élément à un `ArrayList` ?**

- `arrayList.add(element);`
- Exemple : `arrayList.add("Bonjour");`

32. **Qu’est-ce que la méthode `size()` dans une collection ?**

- `size()` retourne le nombre d’éléments présents dans la collection.

33. **Comment itérer sur les éléments d’une `ArrayList` ?**

- Utilisez une boucle `for` ou une boucle `foreach`.
- Exemple :
```java
for (String element : arrayList) {
System.out.println(element);
}
```

34. **Qu’est-ce qu’une classe interne en Java ?**

- Une classe définie à l’intérieur d’une autre classe. Peut être une classe interne
statique ou non statique.

35. **Comment déclarer une classe interne ?**

- `class Externe { class Interne { } }`
- Exemple :
```java
public class Externe {
class Interne {
// membres de la classe interne
}
}
```

36. **Qu’est-ce qu’une classe anonyme en Java ?**

- Une classe sans nom créée et instanciée en une seule ligne, souvent utilisée pour
les implémentations rapides d’interfaces.
37. **Comment utiliser une classe anonyme ?**
- `NomInterface instance = new NomInterface() { // implémentation }`
- Exemple :
```java
Runnable r = new Runnable() {
public void run() {
System.out.println("Exécution de Runnable");
}
};
```

38. **Qu’est-ce qu’un `enum` en Java ?**

- Un `enum` est un type spécial qui définit un ensemble de constantes.

39. **Comment déclarer un `enum` ?**

- `public enum NomEnum { CONSTANTE1, CONSTANTE2, CONSTANTE3 }`
- Exemple :
```java
public enum Jour { LUNDI, MARDI, MERCREDI }
```

40. **Qu’est-ce que le polymorphisme paramétrique ?**

- Le polymorphisme paramétrique permet d'utiliser des types génériques dans les
classes, interfaces et méthodes.

41. **Comment déclarer une classe générique ?**

- `class NomClasse<T> { // code }`
- Exemple :
```java
public class Boite<T> {
private T contenu;
public void mettre(T contenu) { this.contenu = contenu; }
public T retirer() { return contenu; }
}
```

42. **Comment créer une méthode générique ?**

- `public <T> void nomMethode(T param) { // code }`
- Exemple :
```java
public <E> void afficher(E element) {
System.out.println(element);
}
```

43. **Quelle est la différence

entre `==` et `equals()` ?**
- `==` compare les références d'objet, tandis que `equals()` compare les valeurs des
objets.

44. **Comment faire une copie profonde d’un objet ?**

- Utilisez la sérialisation ou implémentez correctement `clone()` avec l'interface
`Cloneable`.

45. **Qu’est-ce que la sérialisation en Java ?**

- La sérialisation est le processus de conversion d'un objet en un format qui peut être
stocké ou transmis.

46. **Comment sérialiser un objet en Java ?**

- Assurez-vous que la classe implémente `Serializable`, puis utilisez
`ObjectOutputStream` pour écrire l'objet dans un flux.

47. **Comment désérialiser un objet en Java ?**

- Utilisez `ObjectInputStream` pour lire l'objet à partir d'un flux.

48. **Qu’est-ce que la synchronisation en Java ?**

- La synchronisation garantit que plusieurs threads accèdent à une ressource
partagée de manière contrôlée.

49. **Comment créer un thread en Java ?**

- En implémentant `Runnable` ou en étendant `Thread`, puis en appelant la méthode
`start()`.

50. **Qu’est-ce que le `try-with-resources` ?**

- Une fonctionnalité qui permet de gérer automatiquement la fermeture des
ressources, comme les flux, en utilisant le mot-clé `try` avec des ressources déclarées
entre parenthèses.