Exercice Java Corrigé – POO – Interfaces

// Ceci est une interface nommée 'Forme' qui définit un contrat pour les classes à implémenter.
interface Forme {    
    // Signature de la méthode abstraite pour récupérer la surface 
    // d'une forme.
    double getSurface();
}

// Ceci est la classe 'Rectangle' qui implémente l'interface 'Forme'.
class Rectangle implements Forme {    
    // Variables d'instance privées pour stocker les dimensions du 
    // rectangle.
    private double longueur;    
    private double largeur;    
    
    // Constructeur pour créer un objet Rectangle avec la longueur et 
    // la largeur données.
    public Rectangle(double longueur, double largeur) {        
        this.longueur = longueur;        
        this.largeur = largeur;    
    }    
    
    // Implémentation de la méthode 'getSurface' comme requis par 
    // l'interface 'Forme'.
    @Override    
    public double getSurface() {        
        // Calculer et retourner la surface du rectangle.
        return longueur * largeur;    
    }
}

// Ceci est la classe 'Cercle' qui implémente l'interface 'Forme'.
class Cercle implements Forme {    
    // Variable d'instance privée pour stocker le rayon du cercle.
    private double rayon;    
    
    // Constructeur pour créer un objet Cercle avec un rayon donné.
    public Cercle(double rayon) {        
        this.rayon = rayon;    
    }    
    
    // Implémentation de la méthode 'getSurface' comme requis par 
    // l'interface 'Forme'.
    @Override    
    public double getSurface() {        
        // Calculer et retourner la surface du cercle en utilisant la 
        // formule : π * r^2.
        return Math.PI * rayon * rayon;    
    }
}

// Ceci est la classe 'Triangle' qui implémente l'interface 'Forme'.
class Triangle implements Forme {    
    // Variables d'instance privées pour stocker la base et la 
    // hauteur du triangle.
    private double base;    
    private double hauteur;    
    
    // Constructeur pour créer un objet Triangle avec une base et une 
    // hauteur données.
    public Triangle(double base, double hauteur) {        
        this.base = base;        
        this.hauteur = hauteur;    
    }    
    
    // Implémentation de la méthode 'getSurface' comme requis par 
    // l'interface 'Forme'.
    @Override    
    public double getSurface() {        
        // Calculer et retourner la surface du triangle en utilisant 
        // la formule : 0,5 * base * hauteur.
        return 0.5 * base * hauteur;    
    }
}

// Classe principale qui crée des objets de Rectangle, Cercle et Triangle.
public class Main {    
    public static void main(String[] args) {        
        // Créer un objet Rectangle avec longueur=10 et largeur=12
        Rectangle r = new Rectangle(10, 12);                
        
        // Créer un objet Cercle avec un rayon=3
        Cercle c = new Cercle(3);                
        
        // Créer un objet Triangle avec une base=4 et une hauteur=6
        Triangle t = new Triangle(4, 6);        
        
        // Afficher la surface du Rectangle
        System.out.println("Surface du Rectangle: "+ r.getSurface());                
        
        // Afficher la surface du Cercle
        System.out.println("Surface du Cercle: "+ c.getSurface());                
        
        // Afficher la surface du Triangle
        System.out.println("Surface du Triangle: "+ t.getSurface());    
    }
}

Sortie:

Surface du Rectangle: 120.0
Surface du Cercle: 28.274333882308138
Surface du Triangle: 12.0

Explication:

En Java, une interface est un type qui définit un contrat que des classes doivent respecter. Elle contient des méthodes abstraites (sans implémentation) que les classes qui l’implémentent doivent obligatoirement définir. Une interface peut aussi contenir des variables (qui sont implicitement public, static, et final), ainsi que des méthodes par défaut et des méthodes statiques avec une implémentation.

// Déclarer l'interface Animal
interface Animal {    
    // Déclarer la méthode abstraite "aboyer" que les classes 
    // implémentant cette interface doivent définir
    void aboyer();
}

// Déclarer la classe Chien, qui implémente l'interface Animal
class Chien implements Animal {    
    // Implémenter la méthode "aboyer" requise par l'interface Animal
    @Override    
    public void aboyer() {        
        // Afficher un message indiquant que le chien aboie
        System.out.println("Le chien aboie !");
    }
}

// Déclarer la classe Main
public class Main {    
    public static void main(String[] args) {        
        // Créer une instance de la classe Chien
        Chien chien = new Chien();                
        
        // Appeler la méthode "aboyer" sur l'instance de Chien
        chien.aboyer();    
    }
}

Sortie:

Le chien aboie !

// Déclarer l'interface Volable
interface Volable {    
    // Déclarer la méthode abstraite "obj_vol" que les classes 
    // implémentant cette interface doivent définir
    void obj_vol();
}

// Déclarer la classe Satellite, qui implémente l'interface Volable
class Satellite implements Volable {    
    // Implémenter la méthode "obj_vol" requise par l'interface 
    // Volable
    @Override    
    public void obj_vol() {        
        // Afficher un message indiquant que le satellite vole
        System.out.println("Le satellite vole");
    }
}

// Déclarer la classe Avion, qui implémente l'interface Volable
class Avion implements Volable {    
    // Implémenter la méthode "obj_vol" requise par l'interface 
    // Volable
    @Override    
    public void obj_vol() {        
        // Afficher un message indiquant que l'avion vole
        System.out.println("L'avion vole");
    }
}

// Déclarer la classe Helicopter, qui implémente l'interface Volable
class Helicopter implements Volable {    
    // Implémenter la méthode "obj_vol" requise par l'interface 
    // Volable
    @Override    
    public void obj_vol() {        
        // Afficher un message indiquant que l'hélicoptère vole
        System.out.println("L'hélicoptère vole");
    }
}

// Déclarer la classe Main
public class Main {    
    public static void main(String[] args) {        
        // Créer un tableau d'objets Volable, incluant un satellite, 
        // un avion et un hélicoptère
        Volable[] objetsVolants = {new Satellite(), new Avion(), new Helicopter()};        
        
        // Itérer à travers le tableau et appeler la méthode 
        // "obj_vol" sur chaque objet
        for (Volable obj : objetsVolants) {            
            obj.obj_vol();        
        }    
    }
}

Sortie:

Le satellite vole
L'avion vole
L'hélicoptère vole

// Importer les bibliothèques requises pour List et ArrayList
import java.util.ArrayList;
import java.util.List;

// Déclarer l'interface Compte
interface Compte {
    // Déclarer la méthode abstraite "deposer" pour déposer un 
    // montant spécifié
    void deposer(double amount);
    
    // Déclarer la méthode abstraite "retirer" pour retirer un 
    // montant spécifié
    void retirer(double amount);
    
    // Déclarer la méthode abstraite "getSolde" pour récupérer le 
    // solde actuel
    double getSolde();
}

// Déclarer la classe CompteEpargne, qui implémente l'interface Compte
class CompteEpargne implements Compte {
    // Déclarer des variables d'instance privées pour stocker le 
    // solde et le taux d'intérêt
    private double solde;
    private double tauxInteret;

    // Constructeur pour initialiser le solde et le taux d'intérêt
    public CompteEpargne(double depotInitial, double tauxInteret) {
        this.solde = depotInitial;
        this.tauxInteret = tauxInteret;
    }

    // Implémenter la méthode "deposer" pour ajouter un montant 
    // spécifié au solde
    @Override
    public void deposer(double montant) {
        solde += montant;
    }

    // Implémenter la méthode "retirer" pour soustraire un montant 
    // spécifié du solde
    @Override
    public void retirer(double montant) {
        solde -= montant;
    }

    // Implémenter la méthode "getSolde" pour récupérer le solde 
    // actuel
    @Override
    public double getSolde() {
        return solde;
    }

    // Méthode pour appliquer les intérêts au solde
    public void appliquerTauxInteret() {
        // Appliquer le taux d'intérêt (en pourcentage) au solde pour 
        // 1 an
        solde += solde * tauxInteret / 100;
    }
}

// Déclarer la classe CompteCourant, qui implémente l'interface Compte
class CompteCourant implements Compte {
    // Déclarer des variables d'instance privées pour stocker le 
    // solde et la limite de découvert
    private double solde;
    private double limiteDecouvert;

    // Constructeur pour initialiser le solde et la limite de 
    // découvert
    public CompteCourant(double depotInitial, double limiteDecouvert) {
        this.solde = depotInitial;
        this.limiteDecouvert = limiteDecouvert;
    }

    // Implémenter la méthode "deposer" pour ajouter un montant 
    // spécifié au solde
    @Override
    public void deposer(double montant) {
        solde += montant;
    }

    // Implémenter la méthode "retirer" pour soustraire un montant 
    // spécifié du solde
    @Override
    public void retirer(double montant) {
        // Vérifier si le solde plus la limite de découvert est 
        // suffisant pour couvrir le retrait
        if (solde + limiteDecouvert >= montant) {
            solde -= montant;
        }
    }

    // Implémenter la méthode "getSolde" pour récupérer le solde 
    // actuel
    @Override
    public double getSolde() {
        return solde;
    }

    // Méthode pour définir la limite de découvert du compte courant
    public void setLimiteDecouvert(double limiteDecouvert) {
        this.limiteDecouvert = limiteDecouvert;
    }
}

// Déclarer la classe Banque
class Banque {
    // Déclarer une liste privée pour stocker les comptes
    private List<Compte> comptes;

    // Constructeur pour initialiser la liste des comptes
    public Banque() {
        comptes = new ArrayList<>();
    }

    // Méthode pour ajouter un compte à la liste des comptes
    public void addCompte(Compte compte) {
        comptes.add(compte);
    }

    // Méthode pour supprimer un compte de la liste des comptes
    public void removeAccount(Compte compte) {
        comptes.remove(compte);
    }

    // Méthode pour déposer un montant spécifié dans un compte
    public void deposer(Compte compte, double montant) {
        compte.deposer(montant);
    }

    // Méthode pour retirer un montant spécifié d'un compte
    public void retirer(Compte compte, double montant) {
        compte.retirer(montant);
    }

    // Méthode pour afficher les soldes de tous les comptes dans la 
    // banque
    public void afficherSoldesComptes() {
        for (Compte compte : comptes) {
            System.out.println("Solde du compte: "+ compte.getSolde());
        }
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer une instance de la classe Banque
        Banque banque = new Banque();

        // Créer un Compte Épargne avec un dépôt initial et un taux 
        // d'intérêt
        CompteEpargne ce = new CompteEpargne(1000.0, 1.25);
        System.out.println("Compte Épargne :\nDépôt initial : 1000.00 €\nTaux d'intérêt : 1,25%");

        // Créer un Compte Courant avec un dépôt initial et une 
        // limite de découvert
        CompteCourant cc = new CompteCourant(5000.0, 1000.0);
        System.out.println("\nCompte Courant:\nDépôt initial: 5000.00 €\nLimite de découvert: 1000.00 €");

        // Ajouter le CompteEpargne et le CompteCourant à la banque
        banque.addCompte(ce);
        banque.addCompte(cc);

        System.out.println("\nDépôt de 100 € sur le Compte Épargne.");
        // Déposer 100 € sur le CompteEpargne
        banque.deposer(ce, 100.0);

        System.out.println("Dépôt de 500 € sur le Compte Courant.");
        // Déposer 500 € sur le CompteCourant
        banque.deposer(cc, 500.0);

        System.out.println("Retrait de 150 € du Compte Épargne.\n");
        // Retirer 150 € du CompteEpargne
        banque.retirer(ce, 150.0);

        System.out.println("\nCompte Épargne et Compte Courant:");
        // Afficher les soldes de tous les comptes dans la banque
        banque.afficherSoldesComptes();

        // Appliquer les intérêts au CompteEpargne
        ce.appliquerTauxInteret();
        System.out.println("\nAprès l'application des intérêts sur le Compte Épargne pour 1 an:");
        System.out.println("Compte Épargne et Compte Courant:");
        // Afficher les soldes de tous les comptes dans la banque 
        // après application des intérêts
        banque.afficherSoldesComptes();
    }
}

Sortie:

Compte Épargne :
Dépôt initial : 1000.00 €
Taux d’intérêt : 1,25%

Compte Courant:
Dépôt initial: 5000.00 €
Limite de découvert: 1000.00 €

Dépôt de 100 € sur le Compte Épargne.
Dépôt de 500 € sur le Compte Courant.
Retrait de 150 € du Compte Épargne.


Compte Épargne et Compte Courant:
Solde du compte: 950.0
Solde du compte: 5500.0

Après l'application des intérêts sur le Compte Épargne pour 1 an:
Compte Épargne et Compte Courant:
Solde du compte: 961.875
Solde du compte: 5500.0

// Déclarer l'interface Redimensionnable
interface Redimensionnable {
    // Déclarer la méthode abstraite "resizeWidth" pour 
    // redimensionner la largeur
    void resizeWidth(int width);
    
    // Déclarer la méthode abstraite "resizeHeight" pour 
    // redimensionner la hauteur
    void resizeHeight(int height);
}

// Déclarer la classe Rectangle, qui implémente l'interface Redimensionnable
class Rectangle implements Redimensionnable {
    // Déclarer des variables d'instance privées pour stocker la 
    // largeur et la hauteur
    private int width;
    private int height;

    // Constructeur pour initialiser la largeur et la hauteur
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // Implémenter la méthode "resizeWidth" pour redimensionner la 
    // largeur
    public void resizeWidth(int width) {
        this.width = width;
    }

    // Implémenter la méthode "resizeHeight" pour redimensionner la 
    // hauteur
    public void resizeHeight(int height) {
        this.height = height;
    }

    // Méthode pour afficher la largeur et la hauteur actuelles du 
    // rectangle
    public void afficherSize() {
        System.out.println("Largeur: "+ width +", Hauteur: "+ height);
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer une instance de la classe Rectangle avec une taille 
        // initiale
        Rectangle rectangle = new Rectangle(100, 150);

        // Afficher la taille initiale du rectangle
        rectangle.afficherSize();

        // Redimensionner le rectangle en changeant sa largeur et sa 
        // hauteur
        rectangle.resizeWidth(160);
        rectangle.resizeHeight(180);

        // Afficher la nouvelle taille du rectangle
        rectangle.afficherSize();
    }
}

Sortie:

Largeur: 100, Hauteur: 150
Largeur: 160, Hauteur: 180

// Importer les bibliothèques nécessaires pour les graphiques et l'interface utilisateur
import java.awt.*;
import javax.swing.*;

// Déclarer l'interface Dessinable
interface Dessinable {
    // Déclarer la méthode abstraite "dessin" que les classes 
    // implémentant cette interface doivent fournir
    void dessin();
}

// Déclarer la classe Cercle, qui implémente l'interface Dessinable
class Cercle implements Dessinable {
    // Implémenter la méthode "dessin" requise par l'interface 
    // Dessinable
    public void dessin() {
        // Créer un nouveau JFrame pour afficher le cercle
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);
        frame.setVisible(true);
        
        // Créer un JPanel pour le dessin personnalisé
        JPanel panel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // Définir la couleur de dessin en rouge et dessiner
                // un cercle
                g.setColor(Color.RED);
                g.fillOval(100, 100, 200, 200);
            }
        };
        
        // Ajouter le panel au cadre (frame)
        frame.add(panel);
    }
}

// Déclarer la classe Rectangle, qui implémente l'interface Dessinable
class Rectangle implements Dessinable {
    // Implémenter la méthode "dessin" requise par l'interface 
    // Dessinable
    public void dessin() {
        // Créer un nouveau JFrame pour afficher le rectangle
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);
        frame.setVisible(true);
        
        // Créer un JPanel pour le dessin personnalisé
        JPanel panel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // Définir la couleur de dessin en bleu et dessiner 
                // un rectangle
                g.setColor(Color.BLUE);
                g.fillRect(100, 100, 200, 200);
            }
        };
        
        // Ajouter le panel au cadre (frame)
        frame.add(panel);
    }
}

// Déclarer la classe Triangle, qui implémente l'interface Dessinable
class Triangle implements Dessinable {
    // Implémenter la méthode "dessin" requise par l'interface 
    // Dessinable
    public void dessin() {
        // Créer un nouveau JFrame pour afficher le triangle
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);
        frame.setVisible(true);
        
        // Créer un JPanel pour le dessin personnalisé
        JPanel panel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // Définir la couleur de dessin en vert et dessiner 
                // un polygone (triangle)
                g.setColor(Color.GREEN);
                int[] xPoints = {
                    200,
                    100,
                    300
                };
                int[] yPoints = {
                    100,
                    300,
                    300
                };
                g.fillPolygon(xPoints, yPoints, 3);
            }
        };
        
        // Ajouter le panel au cadre (frame)
        frame.add(panel);
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer des instances d'objets Dessinable, qui sont Cercle, 
        // Rectangle, et Triangle
        Dessinable cercle = new Cercle();
        Dessinable rectangle = new Rectangle();
        Dessinable triangle = new Triangle();
        
        // Appeler la méthode "dessin" pour afficher chaque forme
        cercle.dessin();
        rectangle.dessin();
        triangle.dessin();
    }
}

Sortie:
 

// Déclarer l'interface Searchable
interface Searchable {
    // Déclarer la méthode abstraite "search" que les classes 
    // implémentant cette interface doivent fournir
    boolean search(String keyword);
}

// Déclarer la classe Document, qui implémente l'interface Searchable
class Document implements Searchable {
    // Déclarer une variable d'instance privée pour stocker le 
    // contenu du document
    private String content;

    // Constructeur pour initialiser le contenu du document
    public Document(String content) {
        this.content = content;
    }

    // Implémenter la méthode "search" requise par l'interface 
    // Searchable
    public boolean search(String keyword) {
        // Vérifier si le contenu contient le mot-clé spécifié
        return content.contains(keyword);
    }
}

// Déclarer la classe, qui implémente l'interface Searchable
class PageWeb implements Searchable {
    // Déclarer des variables d'instance privées pour stocker l'URL 
    // et le contenu HTML
    private String url;
    private String htmlContent;

    // Constructeur pour initialiser l'URL et le contenu HTML
    public PageWeb(String url, String htmlContent) {
        this.url = url;
        this.htmlContent = htmlContent;
    }

    // Implémenter la méthode "search" requise par l'interface 
    // Searchable
    public boolean search(String keyword) {
        // Vérifier si le contenu HTML contient le mot-clé spécifié
        return htmlContent.contains(keyword);
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer une instance de la classe Document avec un contenu 
        // de test
        Document document = new Document("Ceci est un document de test.");

        // Rechercher un mot-clé dans le document et stocker le 
        // résultat
        boolean res1 = document.search("test");

        // Afficher si le document contient le mot-clé
        System.out.println("Le document contient le mot-clé 'test': "+ res1);

        // Créer une instance de la classe PageWeb avec une URL et un 
        // contenu HTML de test
        PageWeb webPage = new PageWeb("https://waytolearnx.com", "Ceci est une page web de test.");

        // Rechercher un mot-clé dans la page web et stocker le 
        // résultat
        boolean res2 = webPage.search("java");

        // Afficher si la page web contient le mot-clé
        System.out.println("La page web contient le mot-clé 'java': "+ res2);
    }
}

Sortie:

Le document contient le mot-clé 'test': true
La page web contient le mot-clé 'java': false

// Déclarer l'interface Sortable (Triable)
interface Sortable {
    // Déclarer la méthode abstraite "sort" que les classes 
    // implémentant cette interface doivent fournir
    void sort(int[] tab);
}

// Déclarer la classe BubbleSort, qui implémente l'interface Sortable
class BubbleSort implements Sortable {
    // Implémenter la méthode "sort" requise par l'interface Sortable
    public void sort(int[] tab) {
        // Obtenir la longueur du tableau
        int n = tab.length;
        
        // Boucle externe pour le nombre de passages
        for (int i = 0; i < n - 1; i++) {
            // Boucle interne pour les comparaisons et les échanges
            for (int j = 0; j < n - i - 1; j++) {
                if (tab[j] > tab[j + 1]) {
                    // Échanger tab[j] et tab[j + 1]
                    int temp = tab[j];
                    tab[j] = tab[j + 1];
                    tab[j + 1] = temp;
                }
            }
        }
    }
}

// Déclarer la classe SelectionSort, qui implémente l'interface Sortable
class SelectionSort implements Sortable {
    // Implémenter la méthode "sort" requise par l'interface Sortable
    public void sort(int[] tab) {
        // Obtenir la longueur du tableau
        int n = tab.length;
        
        // Boucle externe pour l'élément courant
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            // Boucle interne pour trouver l'élément minimum dans la 
            // partie non triée du tableau
            for (int j = i + 1; j < n; j++) {
                if (tab[j] < tab[minIndex]) {
                    minIndex = j;
                }
            }
            // Échanger tab[i] et tab[minIndex]
            int temp = tab[i];
            tab[i] = tab[minIndex];
            tab[minIndex] = temp;
        }
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer un tableau d'entiers à trier
        int[] tab = {5, 9, 2, 0, 7, 4, 1};
        
        // Créer une instance de BubbleSort et effectuer le tri
        Sortable bubbleSort = new BubbleSort();
        bubbleSort.sort(tab);
        System.out.print("Tri à bulles : ");
        afficherTab(tab);
        
        // Créer une instance de SelectionSort et effectuer le tri
        Sortable selectionSort = new SelectionSort();
        selectionSort.sort(tab);
        System.out.print("Tri par sélection : ");
        afficherTab(tab);
    }

    // Méthode pour afficher les éléments d'un tableau
    private static void afficherTab(int[] tab) {
        for (int n : tab) {
            System.out.print(n + " ");
        }
        System.out.println();
    }
}

Sortie:

Tri à bulles : 0 1 2 4 5 7 9 
Tri par sélection : 0 1 2 4 5 7 9 

// Déclarer l'interface Jouable
interface Jouable {
    // Déclarer la méthode abstraite "play" que les classes 
    // implémentant cette interface doivent fournir
    void play();
}

// Déclarer la classe Football, qui implémente l'interface Jouable
class Football implements Jouable {
    public void play() {
        System.out.println("Jouer au football");
    }
}

// Déclarer la classe Volleyball, qui implémente l'interface Jouable
class Volleyball implements Jouable {
    // Implémenter la méthode "play" requise par l'interface Jouable
    public void play() {
        // Afficher un message indiquant que le volleyball est joué
        System.out.println("Jouer au volleyball");
    }
}

// Déclarer la classe Basketball, qui implémente l'interface Jouable
class Basketball implements Jouable {
    // Implémenter la méthode "play" requise par l'interface Jouable
    public void play() {
        // Afficher un message indiquant que le basketball est joué
        System.out.println("Jouer au basketball");
    }
}

// Déclarer la classe Main
public class Main {
    public static void main(String[] args) {
        // Créer des instances d'objets Jouable pour le football, le 
        // volleyball et le basketball
        Jouable football = new Football();
        Jouable volleyball = new Volleyball();
        Jouable basketball = new Basketball();
        
        // Appeler la méthode "play" sur chaque objet Jouable pour 
        // jouer à différents sports
        football.play();
        volleyball.play();
        basketball.play();
    }
}

Sortie:

Jouer au football
Jouer au volleyball
Jouer au basketball

// Importer les bibliothèques nécessaires pour les opérations cryptographiques
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

// Déclarer l'interface Encryptable
interface Encryptable {
    // Déclarer la méthode abstraite "encrypt" que les classes 
    // implémentant cette interface doivent fournir
    String encrypt(String data);

    // Déclarer la méthode abstraite "decrypt" que les classes 
    // implémentant cette interface doivent fournir
    String decrypt(String encryptedData);
}

// Déclarer la classe AES, qui implémente l'interface Encryptable
class AES implements Encryptable {
    // Définir l'algorithme AES comme une constante
    private static final String AES_ALGORITHM = "AES";

    // Déclarer une clé secrète pour stocker la clé de chiffrement
    private SecretKey secretKey;

    // Constructeur pour initialiser la clé de chiffrement
    public AES() {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES_ALGORITHM);
            // Chiffrement AES-128
            keyGen.init(128); 
            // Générer la clé de chiffrement AES
            secretKey = keyGen.generateKey(); 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Implémenter la méthode "encrypt" requise par l'interface 
    // Encryptable
    public String encrypt(String data) {
        try {
            Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
            // Initialiser le cipher en mode chiffrement avec la clé 
            // AES
            cipher.init(Cipher.ENCRYPT_MODE, secretKey); 
            // Chiffrer les données
            byte[] encryptedBytes = cipher.doFinal(data.getBytes()); 
            // Retourner la chaîne encodée en base64 des données 
            // chiffrées
            return Base64.getEncoder().encodeToString(encryptedBytes); 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // Implémenter la méthode "decrypt" requise par l'interface 
    // Encryptable
    public String decrypt(String encryptedData) {
        try {
            // Décoder la chaîne base64
            byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData); 
            Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
            // Initialiser le cipher en mode déchiffrement avec la 
            // clé AES
            cipher.init(Cipher.DECRYPT_MODE, secretKey); 
            // Déchiffrer les données
            byte[] decryptedBytes = cipher.doFinal(encryptedBytes); 
            // Retourner les données déchiffrées sous forme de chaîne
            return new String(decryptedBytes); 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

// Déclarer la classe RSA, qui implémente l'interface Encryptable
class RSA implements Encryptable {
    // Définir l'algorithme RSA comme une constante
    private static final String RSA_ALGORITHM = "RSA";

    // Déclarer une paire de clés pour stocker la clé publique et la 
    // clé privée
    private KeyPair keyPair;

    // Constructeur pour générer une paire de clés pour le 
    // chiffrement et le déchiffrement
    public RSA() {
        try {
            KeyPairGenerator keyGen = KeyPairGenerator.getInstance(RSA_ALGORITHM);
            // Chiffrement RSA-2048
            keyGen.initialize(2048); 
            // Générer la paire de clés RSA (clé publique et privée)
            keyPair = keyGen.generateKeyPair(); 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Implémenter la méthode "encrypt" requise par l'interface 
    // Encryptable
    public String encrypt(String data) {
        try {
            // Obtenir la clé publique de la paire de clés
            PublicKey publicKey = keyPair.getPublic(); 
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            // Initialiser le cipher en mode chiffrement avec la clé 
            // publique
            cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
            // Chiffrer les données
            byte[] encryptedBytes = cipher.doFinal(data.getBytes()); 
            // Retourner la chaîne encodée en base64 des données 
            // chiffrées
            return Base64.getEncoder().encodeToString(encryptedBytes); 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // Implémenter la méthode "decrypt" requise par l'interface 
    // Encryptable
    public String decrypt(String encryptedData) {
        try {
            // Obtenir la clé privée de la paire de clés
            PrivateKey privateKey = keyPair.getPrivate(); 
            // Décoder la chaîne base64
            byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData); 
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            // Initialiser le cipher en mode déchiffrement avec la 
            // clé privée
            cipher.init(Cipher.DECRYPT_MODE, privateKey); 
            // Déchiffrer les données
            byte[] decryptedBytes = cipher.doFinal(encryptedBytes); 
            // Retourner les données déchiffrées sous forme de chaîne
            return new String(decryptedBytes); 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

// Déclarer la classe principale Main
public class Main {
    public static void main(String[] args) {
        // Créer une instance de la classe AES pour le chiffrement et 
        // le déchiffrement
        Encryptable aes = new AES();

        // Chiffrer les données avec AES et stocker le résultat
        String encryptedDataAES = aes.encrypt("Contenu de test.");
        System.out.println("Cryptage AES: "+ encryptedDataAES);

        // Déchiffrer les données chiffrées avec AES et stocker le 
        // résultat
        String decryptedDataAES = aes.decrypt(encryptedDataAES);
        System.out.println("Décryptage AES: "+ decryptedDataAES);

        // Créer une instance de la classe RSA pour le chiffrement et 
        // le déchiffrement
        Encryptable rsa = new RSA();

        // Chiffrer les données avec RSA et stocker le résultat
        String encryptedDataRSA = rsa.encrypt("Contenu de test.");
        System.out.println("Cryptage RSA: "+ encryptedDataRSA);

        // Déchiffrer les données chiffrées avec RSA et stocker le 
        // résultat
        String decryptedDataRSA = rsa.decrypt(encryptedDataRSA);
        System.out.println("Décryptage RSA: "+ decryptedDataRSA);
    }
}

Sortie:

Cryptage AES: niKcCYnOG60xG50v08qeI189fPrfF48SuevM+KaOris=
Décryptage AES: Contenu de test.
Cryptage RSA: o8x1jQT1yYKFEaQ8HvERJu7N9Mp/DZn7Xe2HgGixO6na8B1JdGSGUHJV6CYHTh5/kXhZmkz86+BMBXJO3mhyrHjD/wGacIF6DgEPwyqXu6JAkQSQ2pK0BY/ec+SFWepQdGsjP302fJseR+i6cFXd5+NDzau6Q8Xkd/KTDtej9ALGuqC9vbBv2PjFkeHf/TinlhlLWeZxUqLRZEJHVvYkbnm5lRDxXLRkwPx2p3+X7fIYXLHH2Qz2uyDJNoboA939wTMzXtbMCBKRJTIxfWjulHTaJya5H1v7jrAwIDXgi4PCeJ0VPzO4+R/LbqnCYqNvVj4X79+1H9pcXkTqP3lAKQ==
Décryptage RSA: Contenu de test.