Comment appliquer le concept de polymorphisme POO pour créer des classes concurrentes flexibles et réutilisables en Java ?

1 Interfaces et simultanéité

Une interface est un contrat qui spécifie les méthodes qu’une classe doit implémenter. Vous pouvez utiliser des interfaces pour créer des classes simultanées qui partagent un comportement commun, mais qui ont des implémentations différentes. Par exemple, vous pouvez définir une interface appelée Runnable qui a une exécution() , puis créez différentes classes qui implémentent Runnable et remplacent l’exécution() méthode pour effectuer différentes tâches. Vous pouvez ensuite utiliser un pool de threads pour exécuter ces classes en parallèle, comme illustré dans l’extrait de code suivant :

// Define an interface
public interface Runnable {
  void run();
}

// Create two classes that implement Runnable
public class Task1 implements Runnable {
  @Override
  public void run() {
    // Do something
  }
}

public class Task2 implements Runnable {
  @Override
  public void run() {
    // Do something else
  }
}

// Create a thread pool and execute the tasks
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(new Task1());
executor.execute(new Task2());
executor.shutdown();        

En utilisant des interfaces, vous pouvez obtenir un polymorphisme et une concurrence simultanée, car le pool de threads peut exécuter n’importe quelle classe qui implémente Runnable, quels que soient ses détails spécifiques.

2 Cours abstraits et concurrence

Une classe abstraite est une classe qui ne peut pas être instanciée, mais qui peut avoir des méthodes abstraites ou concrètes. Vous pouvez utiliser des classes abstraites pour créer des classes concurrentes qui ont des fonctionnalités communes, mais aussi des méthodes abstraites qui doivent être remplacées par des sous-classes. Par exemple, vous pouvez définir une classe abstraite appelée Worker qui a un début() et un arrêt() , puis créez différentes sous-classes qui étendent Worker et remplacent le travail abstrait() méthode pour effectuer différentes tâches. Vous pouvez ensuite utiliser une collection simultanée pour stocker et gérer ces collaborateurs, comme illustré dans l’extrait de code suivant :

// Define an abstract class
public abstract class Worker {
  private boolean running;

  // Start the worker
  public void start() {
    running = true;
    work();
  }

  // Stop the worker
  public void stop() {
    running = false;
  }

  // Check if the worker is running
  public boolean isRunning() {
    return running;
  }

  // Define an abstract method
  public abstract void work();
}

// Create two subclasses that extend Worker
public class Worker1 extends Worker {
  @Override
  public void work() {
    // Do something
  }
}

public class Worker2 extends Worker {
  @Override
  public void work() {
    // Do something else
  }
}

// Create a concurrent collection and add the workers
ConcurrentLinkedQueue<Worker> queue = new ConcurrentLinkedQueue<>();
queue.add(new Worker1());
queue.add(new Worker2());

// Start and stop the workers
for (Worker worker : queue) {
  worker.start();
}

for (Worker worker : queue) {
  worker.stop();
}        

En utilisant des classes abstraites, vous pouvez obtenir un polymorphisme et une concurrence simultanée, car la collection simultanée peut stocker et manipuler n’importe quelle classe qui étend Worker, quels que soient ses détails spécifiques.

3 Remplacement de méthode et simultanéité

Le remplacement de méthode est une technique qui vous permet de redéfinir une méthode dans une sous-classe qui a le même nom et la même signature qu’une méthode dans une superclasse. Vous pouvez utiliser le remplacement de méthode pour créer des classes concurrentes qui héritent d’un comportement d’une superclasse, mais aussi le modifier ou l’étendre dans une sous-classe. Par exemple, vous pouvez définir une classe appelée Processor qui possède un processus() Méthode qui se synchronise sur un objet partagé, puis crée différentes sous-classes qui remplacent le processus() Méthode pour effectuer différentes opérations sur l’objet partagé. Vous pouvez ensuite utiliser un service d’exécuteur pour exécuter ces sous-classes en parallèle, comme illustré dans l’extrait de code suivant :

// Define a class
public class Processor {
  private Object lock;

  // Constructor
  public Processor(Object lock) {
    this.lock = lock;
  }

  // Process method
  public void process() {
    synchronized (lock) {
      // Do something
    }
  }
}

// Create two subclasses that override the process method
public class Processor1 extends Processor {
  // Constructor
  public Processor1(Object lock) {
    super(lock);
  }

  // Override the process method
  @Override
  public void process() {
    synchronized (lock) {
      // Do something else
    }
  }
}

public class Processor2 extends Processor {
  // Constructor
  public Processor2(Object lock) {
    super(lock);
  }

  // Override the process method
  @Override
  public void process() {
    synchronized (lock) {
      // Do something different
    }
  }
}

// Create a shared object and an executor service
Object lock = new Object();
ExecutorService executor = Executors.newFixedThreadPool(2);

// Execute the subclasses
executor.execute(new Processor1(lock));
executor.execute(new Processor2(lock));
executor.shutdown();        

En utilisant le remplacement de méthode, vous pouvez obtenir un polymorphisme et une concurrence simultanée, car le service exécuteur peut exécuter n’importe quelle classe qui étend Processor, quels que soient ses détails spécifiques.

4 Voici ce qu’il faut prendre en compte

Il s’agit d’un espace pour partager des exemples, des histoires ou des idées qui ne correspondent à aucune des sections précédentes. Que voudriez-vous ajouter d’autre?