Java Tp N :2
Exercice 1 : Méthode générique
Créez une méthode générique qui prend un tableau d'objets et affiche chacun de ses éléments.
import [Link];
public class GenericArrayPrinter {
// Méthode générique pour afficher les éléments d'un tableau
public static <T> void afficherTableau(T[] tableau) {
for (T element : tableau) {
[Link](element);
}
}
public static void main(String[] args) {
// Exemple avec un tableau d'entiers
Integer[] nombres = {1, 2, 3, 4, 5};
[Link]("Affichage des nombres :");
afficherTableau(nombres);
// Exemple avec un tableau de chaînes
String[] mots = {"Bonjour", "à", "tous", "!"};
[Link]("\nAffichage des mots :");
afficherTableau(mots);
// Exemple avec un tableau de doubles
Double[] valeurs = {3.14, 1.618, 2.718};
[Link]("\nAffichage des valeurs :");
afficherTableau(valeurs);
}
}
Exercice 2 : Création d'une classe générique simple
Créez une classe générique appelée « Box » qui peut contenir un objet de n'importe quel
type. La classe doit avoir les fonctionnalités suivantes : 1. Un constructeur qui initialise la valeur de
l'objet. 2. Une méthode pour récupérer l'objet (getter). 3. Une méthode pour mettre à jour l'objet
(setter). 4. Une méthode « toString() » pour afficher la valeur de l'objet
// Classe générique Box
public class Box<T> {
// Attribut générique pour stocker l'objet
private T objet;
// Constructeur qui initialise l'objet
public Box(T objet) {
[Link] = objet;
}
// Getter : Méthode pour récupérer l'objet
public T getObjet() {
return objet;
}
// Setter : Méthode pour mettre à jour l'objet
public void setObjet(T objet) {
[Link] = objet;
}
// Méthode toString pour afficher la valeur de l'objet
@Override
public String toString() {
return "Box contient : " + objet;
}
// Méthode principale pour tester la classe
public static void main(String[] args) {
// Exemple avec un entier
Box<Integer> boxInt = new Box<>(42);
[Link](boxInt);
[Link]("Valeur actuelle : " + [Link]());
[Link](100);
[Link]("Valeur mise à jour : " + boxInt);
// Exemple avec une chaîne
Box<String> boxString = new Box<>("Bonjour");
[Link]("\n" + boxString);
[Link]("Valeur actuelle : " + [Link]());
[Link]("Au revoir");
[Link]("Valeur mise à jour : " + boxString);
// Exemple avec un double
Box<Double> boxDouble = new Box<>(3.14);
[Link]("\n" + boxDouble);
[Link]("Valeur actuelle : " + [Link]());
[Link](2.718);
[Link]("Valeur mise à jour : " + boxDouble);
}
}
Exercice 3 : Classe générique avec plusieurs paramètres
Créez une classe générique appelée `Pair` qui peut contenir deux objets de types différents.
La classe doit avoir :
1. Deux paramètres de type générique.
2. Un constructeur pour initialiser les deux valeurs.
3. Des getters pour chaque valeur.
4. Une méthode `toString()` pour afficher les valeurs.
// Classe générique Pair
public class Pair<T, U> {
private T first; // Premier objet
private U second; // Deuxième objet
// Constructeur
public Pair(T first, U second) {
[Link] = first;
[Link] = second;
}
// Getters
public T getFirst() {
return first;
}
public U getSecond() {
return second;
}
// Méthode toString
@Override
public String toString() {
return "Pair [First: " + first + ", Second: " + second + "]";
}
// Méthode main : Tests
public static void main(String[] args) {
Pair<Integer, String> pair1 = new Pair<>(1, "Hello");
[Link](pair1);
Pair<String, String> pair2 = new Pair<>("Key", "Value");
[Link](pair2);
Pair<Double, Integer> pair3 = new Pair<>(3.14, 42);
[Link](pair3);
}
}
Exercice 4 : Borne supérieure avec généricité
Créez une méthode générique qui prend une liste d'objets qui étendent la classe « Number »
et retourne la somme de ces nombres
import [Link];
public class SumCalculator {
// Méthode générique avec une borne supérieure
public static <T extends Number> double sommeDesNombres(List<T> liste) {
double somme = 0.0;
// Parcourir la liste et ajouter chaque élément à la somme
for (T nombre : liste) {
somme += [Link](); // Utilisation de doubleValue() pour convertir en
double
}
return somme;
}
public static void main(String[] args) {
// Exemple 1 : Liste d'entiers
List<Integer> listeEntiers = [Link](1, 2, 3, 4, 5);
[Link]("Somme des entiers : " + sommeDesNombres(listeEntiers));
// Exemple 2 : Liste de doubles
List<Double> listeDoubles = [Link](1.5, 2.5, 3.5);
[Link]("Somme des doubles : " + sommeDesNombres(listeDoubles));
// Exemple 3 : Liste de floats
List<Float> listeFloats = [Link](1.2f, 2.3f, 3.4f);
[Link]("Somme des floats : " + sommeDesNombres(listeFloats));
}
}
Exercice 5 : Interface générique
Créez une interface générique appelée « Container » qui possède une méthode « add(T
element) » et une méthode « get() ». Ensuite, implémente cette interface dans une classe appelée «
SimpleContainer »
// Déclaration de l'interface générique Container
public interface Container<T> {
void add(T element); // Méthode pour ajouter un élément
T get(); // Méthode pour récupérer l'élément
}
// Classe SimpleContainer qui implémente l'interface Container
public class SimpleContainer<T> implements Container<T> {
private T element; // Stockage d'un élément générique
// Implémentation de la méthode add
@Override
public void add(T element) {
[Link] = element;
}
// Implémentation de la méthode get
@Override
public T get() {
return element;
}
}
// Classe principale pour tester le fonctionnement
public class Main {
public static void main(String[] args) {
// Exemple 1 : Container pour des entiers
SimpleContainer<Integer> intContainer = new SimpleContainer<>();
[Link](42);
[Link]("Integer Container: " + [Link]());
// Exemple 2 : Container pour des chaînes
SimpleContainer<String> stringContainer = new SimpleContainer<>();
[Link]("Hello, World!");
[Link]("String Container: " + [Link]());
// Exemple 3 : Container pour des doubles
SimpleContainer<Double> doubleContainer = new SimpleContainer<>();
[Link](3.14);
[Link]("Double Container: " + [Link]());
}
}
Exercice 6 : Généricité avec des classes imbriquées
Créez une classe générique « Node » qui représente un nœud dans une liste chaînée.
Chaque nœud contient un élément et une référence vers le nœud suivant. Implémente une méthode
pour ajouter un nouvel élément et afficher la liste.
// Classe générique Node qui représente un nœud dans une liste chaînée
public class LinkedList<T> {
// Classe interne pour un nœud
private static class Node<T> {
T data; // Élément du nœud
Node<T> next; // Référence vers le nœud suivant
// Constructeur pour initialiser le nœud
Node(T data) {
[Link] = data;
[Link] = null; // Le nœud suivant est nul au départ
}
private Node<T> head; // Référence vers le premier nœud de la liste
// Constructeur de la liste
public LinkedList() {
head = null; // La liste commence vide
// Méthode pour ajouter un élément à la fin de la liste
public void add(T element) {
Node<T> newNode = new Node<>(element); // Crée un nouveau nœud avec l'élément
if (head == null) {
head = newNode; // Si la liste est vide, le nouveau nœud devient la tête
} else {
Node<T> current = head;
// Parcours de la liste jusqu'à trouver le dernier nœud
while ([Link] != null) {
current = [Link];
[Link] = newNode; // Ajoute le nouveau nœud à la fin
// Méthode pour afficher la liste
public void display() {
if (head == null) {
[Link]("La liste est vide.");
return;
Node<T> current = head;
while (current != null) {
[Link]([Link] + " -> ");
current = [Link];
[Link]("null"); // Indique la fin de la liste
// Méthode main pour tester la classe
public static void main(String[] args) {
// Création d'une liste chaînée d'entiers
LinkedList<Integer> intList = new LinkedList<>();
[Link](1);
[Link](2);
[Link](3);
[Link](); // Affiche: 1 -> 2 -> 3 -> null
// Création d'une liste chaînée de chaînes de caractères
LinkedList<String> stringList = new LinkedList<>();
[Link]("Bonjour");
[Link]("le");
[Link]("monde");
[Link](); // Affiche: Bonjour -> le -> monde -> null