Comment utiliser le mécanisme de gestion des exceptions Java ?
- PHPzavant
- 2023-05-09 16:07:071342parcourir
Concept
Le concept de gestion des exceptions est né dans les premiers langages de programmation tels que LISP, PL/I et CLU. Pour la première fois, ces langages de programmation ont introduit des mécanismes de gestion des exceptions pour détecter et gérer les conditions d'erreur lors de l'exécution du programme. Les mécanismes de gestion des exceptions ont ensuite été largement adoptés et développés dans des langages de programmation tels que Ada, Modula-3, C++, Python et Java. En Java, la gestion des exceptions permet de gérer les erreurs et les exceptions pendant l'exécution d'un programme. Le mécanisme de gestion des exceptions permet au programme de continuer à s'exécuter lorsqu'une erreur est rencontrée, plutôt que de planter immédiatement. Ce mécanisme rend le programme plus robuste et plus tolérant aux pannes. Les exceptions sont divisées en deux catégories : les exceptions vérifiées et les exceptions non vérifiées
Exceptions vérifiées :
Les exceptions vérifiées font référence aux exceptions qui doivent être gérées au moment de la compilation. Ils sont généralement causés par une erreur du programmeur ou des problèmes avec des ressources externes. Par exemple, IOException, FileNotFoundException, etc. Les exceptions vérifiées doivent être déclarées à l'aide du mot-clé throws dans la signature de la méthode, ou capturées et gérées dans le corps de la méthode à l'aide d'un bloc try-catch. IOException、FileNotFoundException 等。受检异常必须在方法签名中使用 throws 关键字声明，或者在方法体内用 try-catch 块捕获和处理。
非受检异常（Unchecked Exceptions）：
非受检异常是指那些在编译时不强制要求处理的异常。它们通常是由编程错误引起的，如空指针异常（NullPointerException）、数组越界（ArrayIndexOutOfBoundsException）等。非受检异常继承自 java.lang.RuntimeException 类，不需要在方法签名中声明，也不需要强制捕获和处理。
它们的关系如下：
异常处理
Java 使用 try/catch 关键字进行异常捕获，使用 throw 声明抛出异常，示例代码如下：
public class NullPointerExceptionExample {
public static void main(String[] args) {
String nullString = null;
try {
int length = nullString.length();
} catch (NullPointerException e) {
System.out.println("Caught NullPointerException!");
e.printStackTrace();
}
}
}在这个示例中，我们尝试获取一个 null 字符串的长度。当调用 nullString.length() 时，会抛出 NullPointerException。我们使用 try-catch 语句捕获异常并处理它
自定义异常
Java 官方异常不可能预见所有可能发生的错误，有时候你需要结合自己的业务场景，例如以下场景：
当内置的 Java 异常类无法准确描述你所遇到的异常情况时。
需要为特定领域或业务逻辑创建一组特定的异常。
当希望通过自定义异常类向调用者提供更多的上下文信息或特定的错误代码时。
构建特定的异常，这也很简单，继承已有的异常类（最好继承含义差不多的），如下，我们创建一个表示账户余额不足的异常：
public class InsufficientBalanceException extends RuntimeException {
private double balance;
private double amount;
public InsufficientBalanceException(double balance, double amount) {
super("Insufficient balance: " + balance + ", required amount: " + amount);
this.balance = balance;
this.amount = amount;
}
public double getBalance() {
return balance;
}
public double getAmount() {
return amount;
}
}接下来，我们在业务逻辑代码中使用这个自定义异常：
public class BankAccount {
private double balance;
public BankAccount(double balance) {
this.balance = balance;
}
public void withdraw(double amount) throws InsufficientBalanceException {
if (amount > balance) {
throw new InsufficientBalanceException(balance, amount);
}
balance -= amount;
}
}调用者可以捕获并处理这个自定义异常：
public class BankAccountTest {
private static final Logger logger = Logger.getLogger(BankAccountTest.class.getName());
public static void main(String[] args) {
BankAccount account = new BankAccount(1000.00);
try {
account.withdraw(2000.00);
} catch (InsufficientBalanceException e) {
System.out.println("Error: " + e.getMessage());
System.out.println("Current balance: " + e.getBalance());
System.out.println("Required amount: " + e.getAmount());
logger.log(Level.SEVERE, "An exception occurred", e);
}
}
}可以看到自定义异常使我们能够更清晰地表达业务逻辑中可能出现的异常情况，同时为调用者提供更多关于异常的上下文信息。我们还使用 java.util.logging 工具将输出记录到日志中
多重捕获
在 Java 早起版本，处理多个没有共同基类的异常，需要为每一个异常类型编写一个 catch 语句处理，如下：
class CustomException1 extends Exception {
public CustomException1(String message) {
super(message);
}
}
class CustomException2 extends Exception {
public CustomException2(String message) {
super(message);
}
}
public class SingleCatchException {
public static void main(String[] args) {
try {
// 根据参数选择抛出哪种异常
if (args.length > 0 && "type1".equals(args[0])) {
throw new CustomException1("This is a custom exception type 1.");
} else {
throw new CustomException2("This is a custom exception type 2.");
}
} catch (CustomException1 e) {
// 当 CustomException1 发生时，执行此代码块
System.err.println("Error occurred: " + e.getMessage());
} catch (CustomException2 e) {
// 当 CustomException2 发生时，执行此代码块
System.err.println("Error occurred: " + e.getMessage());
}
}
}这样的代码不仅难以阅读，而且也不够简洁。
多重异常捕获机制，它允许在一个 catch 语句中捕获多个异常类型。这种方法可以避免重复的代码，使异常处理更加简洁。以下是一个使用多重异常捕获机制的示例：
public class MultiCatchExample {
public static void main(String[] args) {
try {
// 根据参数选择抛出哪种异常
if (args.length > 0 && "type1".equals(args[0])) {
throw new CustomException1("This is a custom exception type 1.");
} else {
throw new CustomException2("This is a custom exception type 2.");
}
} catch (CustomException1 | CustomException2 e) {
// 当 CustomExceptionType1 或 CustomExceptionType2 发生时，执行此代码块
System.err.println("Error occurred: " + e.getMessage());
}
}
}重新抛出异常
在某些情况下，你可能希望将异常传递给调用者处理，而不是在当前方法中处理。或者需要在捕获异常时执行一些处理操作，如记录日志、清理资源或者添加额外的上下文信息。在这种情况下，你可以在 catch
Exceptions non vérifiées :
Les exceptions non vérifiées font référence à des exceptions qui ne doivent pas être gérées au moment de la compilation. Ils sont généralement causés par des erreurs de programmation, telles qu'une exception de pointeur nul (NullPointerException), un tableau hors limites (ArrayIndexOutOfBoundsException), etc. Les exceptions non contrôlées héritent de la classe java.lang.RuntimeException et n'ont pas besoin d'être déclarées dans la signature de la méthode, ni d'être forcées à être capturées et traitées. Leur relation est la suivante :
Gestion des exceptions
Java utilise le mot-clétry/catchpour intercepter les exceptions et utilisethrowpour déclarer les exceptions. L'exemple de code est le suivant :public class RethrowExceptionExample { public static void main(String[] args) { try { doSomething(); // 可能会抛出异常的方法 } catch (IOException e) { // 异常处理逻辑 System.err.println("An error occurred: " + e.getMessage()); // 重新抛出异常 throw e; } } }In. Dans cet exemple, nous essayons d'obtenir la longueur d'une chaînenull. LorsquenullString.length()est appelé,NullPointerExceptionsera levée. Nous utilisons l'instructiontry-catchpour intercepter l'exception et la gérer
Exception personnalisée
🎜Exception officielle Java Il est impossible de prévoir toutes les erreurs qui peuvent survenir. Parfois, vous devez la combiner avec la vôtre. scénarios commerciaux, tels que les scénarios suivants ：🎜- 🎜Lorsque la classe d'exception Java intégrée ne peut pas décrire avec précision la situation d'exception que vous rencontrez. 🎜
- 🎜Besoin de créer un ensemble spécifique d'exceptions pour un domaine ou une logique métier spécifique. 🎜
- 🎜Lorsque vous souhaitez fournir des informations plus contextuelles ou des codes d'erreur spécifiques à l'appelant via une classe d'exception personnalisée. 🎜
class A {
String s;
public A(String s) {
this.s = s;
}
}
class B {
A a;
public B(A a) {
this.a = a;
}
}
class C {
B b;
public C(B b) {
this.b = b;
}
}
public class BetterNullPointerReports {
public static void main(String[] args) {
C[] ca = {
new C(new B(new A(null))),
new C(new B(null)),
new C(null)
};
for (C c : ca) {
try {
System.out.println(c.b.a.s);
} catch (NullPointerException npe) {
System.out.println(npe);
}
}
}
}). 🎜 Ensuite, nous utilisons cette exception personnalisée dans le code de la logique métier : 🎜import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FinallyExample {
public static void main(String[] args) {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("Error reading file: " + e.getMessage());
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.err.println("Error closing file: " + e.getMessage());
}
}
}
}
}🎜 L'appelant peut intercepter et gérer cette exception personnalisée : 🎜class CustomException extends RuntimeException {}
class CustomExceptionChild extends CustomException {}
interface MyInterface {
void myMethod() throws CustomException;
}
class MyClass1 implements MyInterface {
// 1：抛出与接口方法相同异常
@Override
// public void myMethod() throws FileNotFoundException { // 编译错误，不能抛出不同类型的异常
public void myMethod() throws CustomException {
// ...
}
}
class MyClass2 implements MyInterface {
// 2：即使不抛出任何异常，也没有问题
@Override
public void myMethod() {
}
}
class MyClass3 implements MyInterface {
// 3: 抛出接口方法声明异常的子类异常（或者父类，既相同类型即可）
@Override
public void myMethod() throws CustomExceptionChild {
// ...
}
}🎜 Vous pouvez voir que l'exception personnalisée nous permet d'exprimer plus clairement ce qui peut se produire dans la logique métier Conditions d'exception, tout en fournissant à l'appelant des informations plus contextuelles sur l'exception. Nous utilisons également l'outil java.util.logging pour enregistrer la sortie dans le journal🎜🎜Capture multiple🎜🎜Dans les premières versions de Java, pour gérer plusieurs exceptions sans classe de base commune, vous devez écrire un code pour chaque type d'exception Une instruction catch est traitée comme suit : 🎜import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TryWithResourcesExample {
public static void main(String[] args) {
String fileName = "example.txt";
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("Error reading file: " + e.getMessage());
}
}
}🎜Un tel code est non seulement difficile à lire, mais aussi pas assez concis. 🎜🎜Mécanisme de capture d'exceptions multiples, qui permet de détecter plusieurs types d'exceptions dans une seule instruction catch. Cette approche évite la duplication de code et rend la gestion des exceptions plus concise. Voici un exemple d'utilisation de plusieurs mécanismes de capture d'exceptions : 🎜class Reporter implements AutoCloseable {
String name = getClass().getSimpleName();
public Reporter() {
System.out.println("Creating " + name);
}
@Override
public void close() throws Exception {
System.out.println("Closing " + name);
}
}
class First extends Reporter {}
class Second extends Reporter {}
public class AutoCloseableDetails {
public static void main(String[] args) {
try (First f = new First(); Second s = new Second()) {
System.out.println("In body");
} catch (Exception e) {
System.out.println("Exception caught");
}
}
}🎜 Relance des exceptions 🎜🎜 Dans certains cas, vous souhaiterez peut-être transmettre l'exception à l'appelant pour qu'il la gère au lieu de la gérer dans la méthode actuelle. Ou vous devez effectuer certaines opérations de traitement lors de la détection d'exceptions, telles que la journalisation, le nettoyage des ressources ou l'ajout d'informations contextuelles supplémentaires. Dans ce cas, vous pouvez gérer l'exception dans un bloc catch, puis relancer l'exception d'origine ou lancer une nouvelle exception avec des informations supplémentaires, comme ceci : 🎜class Anything {}
public class TryAnything {
public static void main(String[] args) {
// 假设我们定义的类，不是 AutoCloseable 的对象，会出现编译错误
try (Anything a = new Anything()) { // compile error
System.out.println("In body");
} catch (Exception e) {
System.out.println("Exception caught");
}
}
}🎜Meilleur NPE 🎜🎜NPE (NullPointerExceptions) est une exception très courante. Avant le JDK 14, lorsque des exceptions NPE étaient rencontrées, les informations disponibles étaient limitées. Le JDK 15 introduisait une nouvelle fonctionnalité appelée "Helpful NullPointerExceptions", qui améliorait le diagnostic NullPointerException (NPE). Dans les versions précédentes du JDK, lorsqu'une NullPointerException se produisait, les informations sur l'exception ne fournissaient souvent pas suffisamment de contexte pour aider les développeurs à localiser l'emplacement spécifique du problème. 🎜🎜Exemple de code : 🎜public class ExceptionMatchingExample {
public static void main(String[] args) {
try {
// ... Some code that may throw exceptions ...
throw new FileNotFoundException("File not found");
} catch (FileNotFoundException e) {
System.out.println("Handling FileNotFoundException: " + e.getMessage());
} catch (IOException e) {
System.out.println("Handling IOException: " + e.getMessage());
} catch (Exception e) {
System.out.println("Handling general exception: " + e.getMessage());
}
}
}🎜Dans JDK 14 et les versions précédentes, le résultat de sortie : 🎜🎜🎜# Vous ne pouvez pas du tout voir ce qui n'a pas fonctionné🎜null🎜java.lang.NullPointerException🎜java.lang.NullPointerException🎜🎜🎜 Dans JDK 15 et versions ultérieures, le résultat de sortie est : 🎜# 得到更详细的 NPE 信息
null
java.lang.NullPointerException: Cannot read field "s" because "c.b.a" is null
java.lang.NullPointerException: Cannot read field "a" because "c.b" is null
清道夫：finally
当程序发生了非预期的异常，那么程序会终止运行，但是对于很多需要执行清理操作，这是不可接受的，例如：
关闭资源：在
try块中打开的资源，如文件、数据库连接、网络连接等，需要在完成操作后确保被正确关闭释放锁：在并发编程中，可能会使用锁来同步代码。在释放锁之前，如果发生异常，可能会导致其他线程无法获取锁
回滚事务：在数据库编程中，可能需要在事务中执行一系列操作。如果这些操作中的任何一个失败，事务需要回滚
恢复状态：在执行某些操作时，可能需要更改对象或系统的状态。在操作完成后，可能需要恢复原始状态
对于以上的程序来说，finally 就非常重要了，它可以解决以上程序的清理操作。
示例代码：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FinallyExample {
public static void main(String[] args) {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("Error reading file: " + e.getMessage());
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
System.err.println("Error closing file: " + e.getMessage());
}
}
}
}
}在以上代码中，无论程序是否出错，finally 都可以确保文件被正确关闭
异常的约束
Java 在面向对象中对异常存在颇多约束和限制，其主要目的如下：
保持子类型可替换性：当子类覆盖父类的方法或实现接口的方法时，子类的方法应该满足父类或接口方法的约定
避免意外的异常：如果子类方法可以抛出任意异常，那么调用者在处理异常时可能遇到意外的异常类型，导致程序出错
提高代码可读性：通过限制异常的继承和实现规则，可以使得代码更加清晰和易于理解
促进良好的设计实践：如果子类方法可以抛出任意异常，那么程序员可能会过度依赖异常来处理错误情况，导致代码难以维护
在接口和继承中使用异常，需要遵循以下规则：
子类可以抛出与接口或者父类方法相同的异常。
子类可以不抛出任何异常，即使接口或父类方法声明了异常。这意味着实现类的方法已经处理了这些异常。
子类可以抛出接口方法或父类声明异常的相同类型的异常，因为子类异常依然符合接口方法的约定。
代码示例：
class CustomException extends RuntimeException {}
class CustomExceptionChild extends CustomException {}
interface MyInterface {
void myMethod() throws CustomException;
}
class MyClass1 implements MyInterface {
// 1：抛出与接口方法相同异常
@Override
// public void myMethod() throws FileNotFoundException { // 编译错误，不能抛出不同类型的异常
public void myMethod() throws CustomException {
// ...
}
}
class MyClass2 implements MyInterface {
// 2：即使不抛出任何异常，也没有问题
@Override
public void myMethod() {
}
}
class MyClass3 implements MyInterface {
// 3: 抛出接口方法声明异常的子类异常（或者父类，既相同类型即可）
@Override
public void myMethod() throws CustomExceptionChild {
// ...
}
}try-with-resources
在 Java 7 中，关于自动管理资源。在处理需要关闭的资源（如文件、数据库连接、网络连接等）有了更好的选择，那就是使用 try-catch-finally 进行处理，它对比 finally 具有以下优势：
简化代码：相比
finally显示关闭资源，使用 Try-With-Resources，可以自动关闭资源，从而使代码更简洁、易读。避免资源泄漏：使用 Try-With-Resources 能够确保在退出
try代码块时自动关闭资源，降低资源泄漏的风险。减少错误：Try-With-Resources 能够正确地处理资源关闭过程中的异常，并提供完整的异常信息，有助于减少错误。
示例代码：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TryWithResourcesExample {
public static void main(String[] args) {
String fileName = "example.txt";
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("Error reading file: " + e.getMessage());
}
}
}在这个示例中，我们使用 Try-With-Resources 语句创建了一个 BufferedReader 实例。BufferedReader 实现了 Closeable 接口，因此在退出 try 代码块时，reader 会自动调用 close() 方法以释放资源。
为了一探 Try-With-Resources 的究竟，我们可以创建自定义的 AutoCloseable 类：
class Reporter implements AutoCloseable {
String name = getClass().getSimpleName();
public Reporter() {
System.out.println("Creating " + name);
}
@Override
public void close() throws Exception {
System.out.println("Closing " + name);
}
}
class First extends Reporter {}
class Second extends Reporter {}
public class AutoCloseableDetails {
public static void main(String[] args) {
try (First f = new First(); Second s = new Second()) {
System.out.println("In body");
} catch (Exception e) {
System.out.println("Exception caught");
}
}
}输出结果：
Creating First
Creating Second
In body
Closing Second
Closing First
退出 try 块会调用两个对象的 close() 方法，并以与创建顺序相反的顺序关闭它们。（顺序很重要）。
使用 Try-With-Resource 是很安全的，假设你随意在 Try 头使用对象，会出现编译错误：
class Anything {}
public class TryAnything {
public static void main(String[] args) {
// 假设我们定义的类，不是 AutoCloseable 的对象，会出现编译错误
try (Anything a = new Anything()) { // compile error
System.out.println("In body");
} catch (Exception e) {
System.out.println("Exception caught");
}
}
}异常类型匹配
Java 在抛出异常时，会根据异常类型进行匹配。异常处理程序会从上到下依次检查 catch 子句，看它们是否与抛出的异常类型兼容。当发现兼容的 catch 子句时，Java 就会执行该子句的代码来处理异常。请注意，Java 只会执行与抛出异常类型兼容的第一个 catch 子句。
示例代码：
public class ExceptionMatchingExample {
public static void main(String[] args) {
try {
// ... Some code that may throw exceptions ...
throw new FileNotFoundException("File not found");
} catch (FileNotFoundException e) {
System.out.println("Handling FileNotFoundException: " + e.getMessage());
} catch (IOException e) {
System.out.println("Handling IOException: " + e.getMessage());
} catch (Exception e) {
System.out.println("Handling general exception: " + e.getMessage());
}
}
}在这个示例中，我们抛出了一个 FileNotFoundException，Java 会从上到下检查 catch 子句，看它们是否与 FileNotFoundException 兼容。因为 FileNotFoundException 是 IOException 的子类，它与 FileNotFoundException 和 IOException 的 catch 子句兼容。但是，Java 只会执行第一个兼容的 catch 子句，即 FileNotFoundException 子句。如果没有找到兼容的 catch 子句，Java 会继续在调用栈中查找异常处理程序，直到找到一个合适的处理程序或者程序终止。
输出结果：
Handling FileNotFoundException: File not found
使用指南
异常看似简单易懂，但在处理过程中还需要遵循许多最佳实践，例如：
除非你知道如何处理，否则不要捕获异常（错误处理代码太多，容易干扰主线代码的逻辑和可读性）
不要生吞异常：捕获异常不进行处理会导致异常消失，从而对于线上问题排查，无从下手
捕获具体异常：尽量捕获具体的异常类，而不是捕获泛化的 Exception 类
尽可能的使用多重异常捕获来简化重复代码，并且提高代码的可读性
尽可能的使用 Try-With-Resources 清理资源
自定义异常：在需要时，为特定于你的应用程序的异常情况创建自定义异常
检查型异常是 shit
检查型异常（checked exceptions）在 Java 中引发了很多争议。有些人认为它们是一种有益的设计，可以提高代码的可靠性，而另一些人则认为它们是一种糟糕的设计，会导致代码冗余和难以维护，例如 Martin Fowler （《UML 精粹》、《重构》）作者，也曾在博客发表称：
总的来说，我认为异常很不错，但是 Java 的检查型异常要比好处多
那么检查型异常究竟带来了什么问题 ？ 常见的槽点有：
强制错误处理：检查型异常强制开发者处理异常情况，导致主线代码中充斥着大量和业务逻辑无关的代码
代码冗余：检查型异常可能导致大量的 try-catch 代码块，增加代码冗余，影响代码可读性
异常传递：对于一些需要在多层方法调用中传递异常的情况，检查型异常可能导致开发者不得不为每个方法添加异常声明
Go 也没有异常啊
最几年 Go 语言的成功让很多人加深了这一观点，Go 语言没有检查型异常的概念，但它们的代码依然可以具有很高的可靠性。这表明检查型异常并非是提高代码可靠性的唯一方法。Go 语言的设计者们有意避免了引入检查型异常，主要有以下原因：
代码简洁性：Go 语言的设计者们希望保持代码简洁，避免因为异常处理而产生的大量冗余代码。
显示错误处理：Go 语言鼓励开发者显式地处理错误，而不是通过异常机制隐式地处理。
降低复杂性：异常机制会增加程序的复杂性。Go 语言的设计者们希望通过避免引入异常机制，让程序更简单易懂。
性能开销：异常处理机制可能会带来一定的性能开销，通过返回 error 类型，可以避免这种性能开销。
示例代码：
package main
import (
"errors"
"fmt"
)
func divide(a, b int) (int, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 2)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
result, err = divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}在这个示例中，我们定义了一个名为divide的函数，它接受两个整数参数a和b，计算它们的商。如果b为零，函数将返回一个非空的error类型值，以指示发生了错误。否则，函数将返回商和一个空error值。在 main 函数中，我们调用divide两次，一次使用一个非零除数，另一次使用零作为除数。对于第一次调用，divide将返回一个空的error值，我们就可以打印出计算结果。对于第二次调用，divide将返回一个非空的error值，我们使用if err != nil来检查这个值是否为nil，如果不是，就打印错误信息。
输出结果：
Result: 5
Error: division by zero
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Articles Liés
Voir plus- Quelle méthode Java est la meilleure pour une conversion efficace d’entier en chaîne ?
- Rédiger votre CV en tant que développeur
- Comment convertir un tableau de valeurs JSON en tableau Java ?
- Comment Java gère-t-il le passage d'objets : par valeur ou par référence ?
- Pourquoi le chiffrement et le déchiffrement 3DES en Java ne parviennent-ils généralement pas à déchiffrer le texte chiffré jusqu'à la chaîne d'origine, et comment ce problème peut-il être résolu ?