Pause café #220. Comment corriger les exceptions en Java – Un guide détaillé

Source : JavaTechOnline Ce didacticiel vous aidera à apprendre à corriger les exceptions courantes en Java. En plus de la théorie, vous verrez des exemples de code pour résoudre de tels problèmes. Comme pour les autres langages de programmation, les développeurs Java peuvent rencontrer des erreurs ou des exceptions lors de l'écriture du code. Les exceptions doivent être prises au sérieux car leur apparition prend du temps de travail. Cependant, avec un peu de connaissances, vous pouvez accélérer la résolution de la plupart de ces problèmes. Apprenons donc à corriger les exceptions courantes en Java.

Directives générales pour éviter les exceptions en Java

Pour éviter de générer des exceptions en Java, il est important de comprendre et de suivre les directives de codage :

1. Validez toujours la saisie de l’utilisateur avant de l’utiliser dans votre code.
2. Utilisez try-catch , throws , throw block , selon ce qui est approprié pour un scénario particulier.
3. Ne négligez pas les messages dans le code concernant le traitement et les erreurs. Cela aidera à identifier et à corriger les problèmes.
4. Assurez-vous de consigner les exceptions à des fins de débogage. Vous pouvez utiliser les messages de l'enregistreur pour vous aider à identifier les problèmes.
5. Suivez les meilleures pratiques de codage pour éviter les exceptions et testez minutieusement votre code.
6. Mettez à jour vos dépendances d'API pour vous assurer que vous utilisez les versions les plus récentes et les plus stables des bibliothèques et des frameworks.
7. Utilisez les outils et les cadres de test nécessaires pour identifier les problèmes potentiels dans votre code avant qu'ils ne génèrent des exceptions.
8. Surveillez les performances et les journaux de votre application pour identifier et résoudre rapidement tout problème.
9. Restez à jour avec les meilleures pratiques de sécurité pour garantir que votre code est sécurisé et protégé contre toute attaque potentielle.
10. Documentez soigneusement votre code et ses exceptions pour le rendre plus facile à comprendre et à maintenir par les autres développeurs.

Liste des exceptions les plus courantes en Java

Java a une liste d'exceptions assez longue. Examinons quelques-uns des plus courants :

NullPointerException

NullPointerException est un type d' exception RuntimeException . Cela se produit lorsque nous essayons d'utiliser une variable de référence qui a une valeur nulle. Cela signifie qu'il pointe vers un objet ou une variable dont la valeur est null . Une telle erreur peut se produire lorsque nous essayons d'appeler une méthode ou d'accéder à un champ d'un objet qui n'a pas été initialisé, ou lorsque nous passons null en paramètre à une méthode qui ne le gère pas. Pour empêcher une NullPointerException d'être levée , vous pouvez vérifier si une variable de référence est nulle à l'aide de l' opérateur == . Si tel est le cas, le cas nul doit être traité correctement. Alternativement, nous pouvons initialiser nos variables aux valeurs par défaut (si possible) pour garantir que nous ne rencontrons jamais de référence nulle. Une autre façon d'éviter une NullPointerException consiste à utiliser la classe Optionnel . En Java, un facultatif est un objet conteneur qui peut ou non contenir une valeur non nulle. Il est utilisé pour représenter la présence ou l'absence d'une valeur, de la même manière que la valeur nulle est utilisée pour représenter l'absence d'une valeur. Si un programmeur tente d'accéder à la valeur vide d'un objet facultatif , le programme ne lancera pas d' exception NullPointerException mais renverra à la place un objet facultatif vide . En d’autres termes, Optionnel force le programmeur à gérer le cas où la valeur est manquante, ce qui permet d’éviter une NullPointerException .

IndexOutOfBoundsException

IndexOutOfBoundsException est une exception d'exécution qui est levée lorsque l'index utilisé pour accéder à un tableau ou une collection est négatif ou supérieur ou égal à la taille du tableau ou de la collection. Pour éviter que cette exception ne se produise, nous devons nous assurer que l'index utilisé pour accéder au tableau ou à la collection est dans ses limites, c'est-à-dire qu'il doit être supérieur ou égal à zéro et inférieur à la taille du tableau ou de la collection.

ArrayIndexOutOfBoundsException

ArrayIndexOutOfBoundsException est un type d' IndexOutOfBoundsException qui est levé lorsqu'une tentative est effectuée pour accéder à un tableau à un index non valide. En Java, les indices de tableau commencent à 0 et se terminent à length()-1 , où length() est le nombre d'éléments dans le tableau. Si vous essayez d'accéder à un élément à un index en dehors de cette plage, Java lancera une ArrayIndexOutOfBoundsException . Lorsque vous rencontrez une ArrayIndexOutOfBoundsException , vous devez revoir votre code pour vous assurer que vous utilisez les indices corrects lors de l'accès aux éléments du tableau.

StringIndexOutOfBoundsException

StringIndexOutOfBoundsException est un type IndexOutOfBoundsException qui est levé lorsqu'une tentative est effectuée pour accéder à un caractère dans une chaîne qui a un index non valide. Comme pour le précédent ArrayIndexOutOfBoundsException , rappelez-vous qu'en Java, l'index d'une chaîne commence à 0 et se termine à length()-1 , où length() est le nombre de caractères dans la chaîne. Si vous essayez d'accéder à un caractère à un index en dehors de cette plage, vous pouvez rencontrer une StringIndexOutOfBoundsException . Si vous rencontrez une StringIndexOutOfBoundsException , vous devez revoir votre code pour vous assurer que vous utilisez les indices corrects lors de l'accès aux caractères de la chaîne.

ClassCastException

Cette exception se produit lorsque nous essayons de convertir un objet en un type incompatible avec son type réel. Pour résoudre un problème comme celui-ci, il est important de vous assurer que votre programme Java tente uniquement de convertir des objets vers les classes dont ils sont des instances. Vous pouvez vérifier le type d'un objet à l'aide de l' opérateur instanceof avant d'appliquer la conversion.

Exception d'argument illégal

IllegalArgumentException est un type de RuntimeException qui est levé lorsqu'une méthode est appelée avec un argument illégal ou inapproprié. En d’autres termes, cette erreur peut se produire lorsqu’une méthode est appelée avec un argument qui se situe en dehors de la plage attendue ou qui n’a pas le format ou la structure attendue. Par exemple, une méthode nécessite un nombre positif comme argument et nous fournissons un nombre négatif, ce qui n'est pas une entrée valide. Si vous rencontrez une IllegalArgumentException , vous devez vérifier votre code pour vous assurer que vous appelez des méthodes avec des arguments valides et appropriés.

IllegalStateException

IllegalStateException est un type de RuntimeException qui est levé lorsqu'un objet est dans un état inapproprié pour l'opération en cours. Cela peut se produire si une méthode est appelée sur un objet qui n'est pas dans l'état attendu. Par exemple, si nous créons un objet de connexion à une base de données puis le fermons. Ensuite, si nous essayons de créer un objet Statement dans une connexion fermée, il lèvera une IllegalStateException car la méthode createStatement() nécessite une connexion ouverte. Si vous rencontrez une IllegalStateException , vous devez revoir votre code pour vous assurer que vous appelez des méthodes sur des objets qui se trouvent dans l'état approprié.

Exception d'opération non prise en charge

UnsupportedOperationException est un type RuntimeException qui est levé lorsqu'une tentative est effectuée pour effectuer une opération non prise en charge sur un objet. Cette erreur peut se produire lorsque nous appelons une méthode qui n'est pas implémentée par l'objet ou qui n'est pas prise en charge par l'objet. Pour éviter qu'une exception ne soit levée, nous ne devons pas appeler de telles opérations qui ne sont pas prises en charge sur les objets. Nous devons revoir notre code pour nous assurer que nous appelons des méthodes sur des objets qui prennent en charge l'opération.

ArithmétiqueException

ArithmeticException est un type de RuntimeException qui est levé lorsqu'une opération arithmétique produit un résultat non valide. Cette exception peut se produire lorsque nous essayons d'effectuer une opération arithmétique avec un argument invalide ou invalide. Par exemple, lorsque vous essayez de diviser par zéro. Pour résoudre ce problème, nous pouvons effectuer une validation des entrées et nous assurer que les arguments remplissent les conditions requises avant d'effectuer l'opération arithmétique.

Exception de sécurité

SecurityException est un type de RuntimeException qui est levé lorsqu'une violation de sécurité se produit lors de l'exécution d'un programme. Cette erreur peut se produire lorsqu'un programme tente d'effectuer une opération non autorisée par la politique de sécurité. Pour résoudre le problème, nous devons nous assurer que nous avons accès aux ressources et effectuer des opérations pour lesquelles nous disposons d’une autorisation spécifique.

NumberFormatException

NumberFormatException est un type de RuntimeException qui est levé lorsqu'une méthode est appelée pour convertir une chaîne au format numérique, mais que la chaîne n'est pas au format approprié. Pour résoudre ce problème, il faut d'abord valider la saisie de l'utilisateur avant de tenter de la convertir. Vérifiez également votre code pour vous assurer que vous essayez de convertir des chaînes formatées de manière appropriée pour le type numérique cible.

Exception interrompue

InterruptedException est une exception vérifiée qui est levée si un thread est en attente, en veille ou bloque un événement et que cet événement est interrompu par un autre thread. L'erreur peut se produire lorsqu'un thread attend une entrée, libère un verrou ou effectue une autre opération et qu'un autre thread interrompt le thread en attente. Pour résoudre ce problème, vous pouvez intercepter InterruptedException et répondre en nettoyant les ressources, en arrêtant le thread ou en prenant toute autre action appropriée. Si vous rencontrez une InterruptedException , vous devez vérifier votre code pour vous assurer que vous gérez correctement les interruptions de thread.

FileNotFoundException

FileNotFoundException est une exception vérifiée qui est levée lorsqu'un programme tente d'accéder à un fichier qui n'existe pas ou est introuvable à l'emplacement spécifié. Il peut apparaître si un fichier est mal orthographié, déplacé ou supprimé, ou même lorsqu'un programme ne dispose pas des autorisations nécessaires pour accéder au fichier. Pour corriger l'erreur, vous pouvez effectuer une validation d'entrée pour vous assurer que le chemin du fichier est correct et que le programme dispose des autorisations nécessaires pour accéder au fichier.

IOException

IOException est une exception vérifiée en Java qui représente une erreur rencontrée lors de l'exécution d'opérations d'entrée ou de sortie, telles que la lecture ou l'écriture dans un fichier ou une socket réseau. Cela peut se produire pour plusieurs raisons, telles que le fichier spécifié manquant ou inaccessible, une erreur réseau ou des autorisations insuffisantes. Pour résoudre le problème, vous devez effectuer plusieurs actions telles que vérifier le message d'erreur, gérer l'exception à l'aide de try-catch , fermer les ressources, vérifier l'autorisation du fichier, etc.

NoSuchMethodException

NoSuchMethodException est une exception levée lors de l'exécution lorsque nous essayons d'appeler une méthode qui n'existe pas dans la classe. Cette exception se produit généralement si nous appelons une méthode à l’aide de Class.getMethod() ou Class.getDeclaredMethod() et que le nom de méthode spécifié n’est pas trouvé dans la classe ou l’interface. Une exception peut également se produire lorsque nous essayons d'appeler une méthode à l'aide de la classe java.lang.reflect.Method et que le nom de méthode spécifié n'existe pas dans l'objet. Pour éviter cette exception, veillez à appeler une méthode valide avec la signature de méthode et le spécificateur d'accès corrects.

NoSuchFieldException

NoSuchFieldException est une exception d'exécution qui se produit lorsque nous essayons d'accéder à un champ qui ne fait pas partie de la classe. Cette exception se produit généralement lorsque nous appelons une méthode à l'aide de Class.getField() ou Class.getDeclaredField() et que le nom du champ spécifié est introuvable dans la classe ou l'interface. De plus, il peut également être appelé si nous essayons d'accéder à un champ à l'aide de la classe java.lang.reflect.Field et que le nom de champ spécifié n'existe pas dans l'objet. Pour éviter cette exception, assurez-vous que vous accédez à un champ valide avec le nom et les modificateurs d'accès corrects. Si vous accédez à un champ privé, veillez à utiliser la méthode getDeclaredField() au lieu de la méthode getField() .

Exception d'accès illégal

IllegalAccessException est une exception d'exécution qui se produit lorsque nous essayons d'accéder à un champ ou à une méthode dans une classe mais que nous n'avons pas les droits d'accès requis. Cette exception apparaît généralement lorsque nous essayons d'accéder à un champ ou une méthode privée depuis l'extérieur d'une classe ou lorsque nous essayons d'accéder à un champ ou une méthode protégé à partir d'une classe qui n'est pas une sous-classe de la classe d'origine. Il peut également être appelé lors d'une tentative d'accès à un champ ou à une méthode marquée comme indisponible par la classe java.lang.reflect.AccessibleObject . Pour éviter ce problème, assurez-vous de disposer des autorisations nécessaires sur le champ ou la méthode à laquelle vous essayez d'accéder. Si le champ ou la méthode est privé, vous devrez peut-être utiliser la réflexion et définir AccessibleObject sur true (pour y accéder). Cependant, soyez prudent lorsque vous utilisez la réflexion pour accéder à des champs ou des méthodes privés, car cela peut rompre l'encapsulation et compromettre l'intégrité de la classe.

VérifierErreur

VerifyError est une erreur d'exécution qui est une sous-classe de LinkageError . Cela se produit lorsque la machine virtuelle Java (JVM) rencontre un fichier de classe qui viole certaines règles de validation. Lorsqu'une classe Java est compilée, le compilateur vérifie si le bytecode suit certaines règles et restrictions, telles que la sécurité des types et l'utilisation correcte de la pile et des variables locales. Si un fichier de classe enfreint ces règles, la JVM générera une VerifyError lors du chargement et de la vérification de la classe au moment de l'exécution. Pour éviter VerifyError , assurez-vous que votre code suit la syntaxe et la sémantique correctes du langage Java. Si vous rencontrez une VerifyError , vous devez vérifier votre code pour vous assurer qu'il est valide et qu'il n'y a aucune violation des règles de vérification du bytecode Java.

Erreur de mémoire insuffisante

OutOfMemoryError est une sous-classe de Error , un type Throwable qui introduit des problèmes graves qui ne peuvent pas être résolus au moment de l'exécution. Même si Java 8 inclut certaines améliorations en matière de garbage collection et de gestion de la mémoire, vous pouvez toujours rencontrer une erreur OutOfMemoryError si votre application utilise trop de mémoire ou gère mal l'utilisation de la mémoire. Pour éviter OutOfMemoryError , vous devez gérer correctement l'utilisation de la mémoire dans votre application Java. Cela implique d'utiliser des structures de données et des algorithmes qui utilisent efficacement la mémoire, en évitant la création d'objets inutiles et en supprimant correctement les objets lorsqu'ils ne sont plus nécessaires. De plus, vous pouvez augmenter la taille maximale du segment de mémoire de la JVM en utilisant l' indicateur -Xmx lors de l'exécution de votre programme Java.

StackOverflowError

StackOverflowError est un type d'erreur qui se produit lorsque la taille de la pile requise par un programme dépasse la quantité de mémoire qui lui est allouée. Cela peut se produire lorsqu'un programme appelle trop de méthodes imbriquées ou lorsqu'une méthode s'appelle de manière récursive trop de fois, ce qui entraîne une boucle infinie. La machine virtuelle Java (JVM) alloue une quantité fixe de mémoire pour la pile d'exécution, qui est utilisée pour suivre les appels de méthode et les variables locales. Lorsque la pile déborde, la JVM renvoie une StackOverflowError . Pour éviter StackOverflowError , il est important de vous assurer que votre programme Java utilise adéquatement la récursivité et les appels de méthode. Si vous rencontrez une StackOverflowError , vous pouvez essayer d'augmenter la taille de la pile en utilisant l' indicateur -Xss lors de l'exécution de votre programme Java.

InvocationTargetExceptionInvocationTargetException

InvocationTargetException est une exception vérifiée levée par le mécanisme de réflexion Java. Il fait partie du package java.lang.reflect.InvocationTargetException et est utilisé pour indiquer qu'une exception s'est produite lors d'un appel de méthode ou de constructeur. Lorsqu'une méthode ou un constructeur est invoqué à l'aide du mécanisme de réflexion Java, la méthode Invoke() de la classe java.lang.reflect.Method ou java.lang.reflect.Constructor est appelée . Si la méthode ou le constructeur invoqué lève une exception, la méthode Invocation() l'intercepte et l'enveloppe dans une InvocationTargetException . Cette exception est ensuite transmise à l'appelant de la méthode Invocation() . Pour corriger l'InvocationTargetException , nous devons l'attraper, obtenir l'exception de cause première à l'aide de la méthode getCause() et gérer l'exception de cause première en conséquence. Notez que la cause première peut être une exception vérifiée ou une exception d’exécution, alors assurez-vous de la gérer correctement.

Façons de corriger les exceptions les plus courantes en Java

Comment réparer NullPointerException

Scénario : Vous disposez d'une méthode qui accède à un objet qui a la valeur null .

String title= null;
System.out.println(title.length()); // Это вызовет NullPointerException

Solution n°1 : Vérifiez si l'objet est nul avant utilisation.

if(title!= null) {
   System.out.println(title.length());
} else {
   System.out.println("title is null");
}

Solution n°2 : utilisez Facultatif pour éviter NullPointerException .

Optional<String> optionalTitle = Optional.ofNullable(getTitle());
if (optionalTitle.isPresent()) {
   String title= optionalTitle.get();
   System.out.println("Title: " + title);
} else {
   System.out.println("Title is not available.");
}

Comment corriger l'exception ArrayIndexOutOfBoundsException

Scénario : vous essayez d'accéder à un tableau à un index situé en dehors de ses limites.

int[] numbers = {4, 5, 6};
System.out.println(numbers[3]);   // Это вызовет ArrayIndexOutOfBoundsException

Solution : vérifiez la longueur du tableau avant d'y accéder et assurez-vous que vous utilisez des index valides.

int[] numbers = {4, 5, 6};
if (numbers.length > 3) {
   System.out.println(numbers[3]);
} else {
   System.out.println("ArrayIndexOutOfBoundsException: Please use valid indexes of the Array");
}

Comment réparer ClassCastException

Scénario : vous essayez de convertir un objet en un type incompatible avec son type réel.

Object obj = "Java Exception";
Integer number = (Integer) obj; // Это вызовет ClassCastException

Solution : assurez-vous de convertir uniquement les objets vers des types avec lesquels ils sont compatibles.

Object obj = "Java Exception";
if(obj instanceof Integer) {
   Integer number = (Integer) obj;
   System.out.println(number);
} else {
   System.out.println("Object cannot caste to Integer");
}

Comment réparer IllegalArgumentException

Scénario : Vous avez transmis un argument non valide à une méthode.

public void printNumber(int number) {
   if(number <= 0) {
      throw new IllegalArgumentException("You cannot pass a negative number or zero");
   }
   System.out.println(number);
}

printNumber(-1); // Это вызовет IllegalArgumentException

Solution : assurez-vous de transmettre des arguments valides aux méthodes. Dans ce cas, transmettez un nombre positif.

printNumber(1); //  Это успешно напечатает 1.

Comment réparer IllegalStateException

Scénario : L'objet est dans un état non valide.

public class Bike {

   private Boolean isStarted;

   public void start() {
      if(isStarted) {
        throw new IllegalStateException("Bike is already started");
      }
      isStarted = true;
      System.out.println("Bike started");
   }
}

Bike bike= new Bike();
bike.start();
bike.start(); // Это вызовет IllegalStateException потому что bike is already started

Solution : assurez-vous de conserver correctement l'état de l'objet.

Bike bike= new Bike();
bike.start();

Comment réparer l'exception UnsupportedOperationException

Scénario : Vous utilisez une opération qui n'est pas prise en charge par un objet. Un exemple courant est que lorsque vous utilisez l' opération Remove() sur une collection immuable, vous verrez probablement une exception UnsupportedOperationException .

List<String> list = Arrays.asList("Java", "Angular", "Spring");
list.add("Python"); // Это вызовет UnsupportedOperationException

Étant donné que la méthode Arrays.asList() renvoie une liste immuable, elle ne prend pas en charge l'ajout ou la suppression d'éléments. Solution : assurez-vous d'appeler uniquement les opérations prises en charge sur les objets.

List<String> list = new ArrayList<>(Arrays.asList("Java", "Angular" "Spring"));
list.add("Python");
System.out.println(list);

Comment réparer ArithmeticException

Scénario n°1 : vous essayez d'effectuer une opération de division entière qui produit un résultat fractionnaire.

int i = 10;
int j = 4;
int k = i/j; // Это вызовет исключение ArithmeticException: целочисленное деление будет дробным

Ici, le résultat de l’opération de division est 2,5, ce qui est une valeur fractionnaire. Étant donné que les entiers ne peuvent pas stocker de valeurs fractionnaires, une ArithmeticException est levée . Solution : Pour éviter cette exception, nous pouvons utiliser un type de données prenant en charge les valeurs fractionnaires, telles que double , pour stocker le résultat de l'opération de division. Voici un exemple :

int i = 10;
int j = 4;
double k = (double) i/j;

Scénario n°2 : vous essayez de diviser par zéro et vous obtenez cette exception. C'est le scénario le plus courant.

int i = 4;
int j = 0;
int k = i/j; // Это вызовет исключение ArithmeticException: нельзя делить на ноль

Solution : gérez correctement la division par zéro. Par exemple, le code ci-dessous démontre un traitement correct.

int i = 4;
int j = 0;
if(j != 0) {
int k = i/j;
System.out.println(k);
} else {
System.out.println("ArithmeticException: Cannot divide by zero");
}

Comment corriger l'exception IndexOutOfBoundsException

Scénario : vous essayez d'accéder à une collection avec un index qui se trouve en dehors de celle-ci.

List<String> list = Arrays.asList("Apple", "Papaya", "Mango");
System.out.println(list.get(3)); // Это вызовет IndexOutOfBoundsException

Solution : vérifiez la taille de la collection avant d'y accéder et assurez-vous que vous utilisez des index valides.

List<String> list = Arrays.asList("Apple", "Papaya", "Mango");
if (list.size() > 3) {
   System.out.println(list.get(3));
} else {
   System.out.println("You are using the Index which is out of bounds");
}

Comment réparer IOException

Scénario : Une opération d'entrée/sortie échoue car le fichier n'est pas accessible.

try {
   File inputFile = new FileReader("pqr.txt");
   BufferedReader reader = new BufferedReader(inputFile);
   String line = reader.readLine();
   System.out.println(line);
} catch (IOException e) {
   e.printStackTrace();
}

Solution : gérez les erreurs d’E/S et assurez-vous que les ressources sont correctement fermées.

File inputFile = new File("pqr.txt");

if (!inputFile.exists() || !inputFile.canRead()) {
 System.out.println("The input file is missing or not readable.");
 return;
}

try {
BufferedReader reader = new BufferedReader(inputFile);
 String line = reader.readLine();
 System.out.println(line);
  reader.close();
} catch (IOException e) {
 e.printStackTrace();
}

Notez qu'à titre d'alternative, nous pouvons utiliser la fonctionnalité try-with-resource introduite dans Java 7 pour fermer automatiquement les ressources, comme indiqué ci-dessous. Nous pouvons déclarer une ou plusieurs ressources dans une instruction try et Java fermera automatiquement les ressources à la fin du bloc, que le bloc se termine normalement ou qu'une exception soit levée.

try (BufferedReader reader = new BufferedReader(new FileReader("pqr.txt"))) {
....
} catch {
....
}

Comment réparer l'exception FileNotFoundException

Scénario : Le fichier est introuvable à l'emplacement spécifié.

try {
     BufferedReader reader = new BufferedReader(new FileReader("abc.txt"));
     String line = reader.readLine();
     System.out.println(line);
     reader.close();
} catch (FileNotFoundException | IOException e) {
     System.out.println("An error has occurred while reading the file: " + e.getMessage());
}

Solution : assurez-vous que le fichier existe et que vous disposez des autorisations appropriées pour y accéder.

try {
    File file = new File("abc.txt");
    if(!file.exists()) {
    throw new FileNotFoundException("File not found at the specified location");
    }
    BufferedReader reader = new BufferedReader(new FileReader(file));
    String line = reader.readLine();
    System.out.println(line);
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}

Comment réparer NoSuchMethodException

Scénario : Si vous essayez d'accéder à une méthode introuvable.

public class TestClass {
   public void sayHello() {
      System.out.println("Hello");
   }
}

TestClass obj = new TestClass();
Method method = obj.getClass().getMethod("printHello"); // Это вызовет NoSuchMethodException

Solution : Vérifiez que la méthode existe et que le nom et la signature de la méthode sont corrects.

public class TestClass {
   public void sayHello() {
      System.out.println("Hello");
   }
}

TestClass  obj = new TestClass();
try {
    Method method = obj.getClass().getMethod("sayHello");
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}

Comment réparer ConcurrentModificationException

Scénario : une collection change pendant son itération.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
for (String str : list) {
  list.remove(str);  // Это вызовет ConcurrentModificationException
}

Solution : utilisez un itérateur pour parcourir une collection et la modifier à l'aide des méthodes d'itérateur.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String str = iterator.next();
    iterator.remove();
}