当然可以实现你的需求，但得先搞定两个核心问题：变量作用域和Java的引用传递特性。咱们结合你的场景一步步拆解：

问题核心分析 #

你原来的代码里，car是try块内的局部变量，catch块根本访问不到它；而且要求fix()不能返回值，所以没法直接把新对象传出来。那咱们得换个思路：用一个引用容器来装car，让异常类能通过容器修改里面的对象引用。

具体实现步骤 #

1. 调整Automobile类，添加构造校验和合法对象创建方法 #

首先让Automobile的构造函数在参数非法时抛出CustomException，同时提供一个静态方法生成合法对象：

class Automobile {
    private String name;
    private Double price;

    // 构造时校验参数，非法则抛异常
    public Automobile(String name, Double price) throws CustomException {
        if (price == null || price < 0) {
            // 把构造参数name传递给异常
            throw new CustomException("价格非法，不能小于0", name);
        }
        this.name = name;
        this.price = price;
    }

    // 生成合法的默认汽车对象
    public static Automobile createValid(String name) {
        try {
            return new Automobile(name, 100.00); // 默认合法价格
        } catch (CustomException e) {
            // 这里不会触发，因为价格是合法的
            return null;
        }
    }

    // Getter用于获取name
    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Automobile{name='" + name + "', price=" + price + "}";
    }
}

2. 改造CustomException类，持有构造参数和引用容器 #

让CustomException保存构造时的合法参数（比如name），并且接收外部的引用容器，这样fix()方法就能修改容器里的对象：

class CustomException extends Exception {
    private String carName;
    private AtomicReference<Automobile> carContainer;

    // 构造函数接收错误信息、汽车名称
    public CustomException(String message, String carName) {
        super(message);
        this.carName = carName;
    }

    // 给异常设置容器的方法
    public void setCarContainer(AtomicReference<Automobile> container) {
        this.carContainer = container;
    }

    public void fix() {
        // 创建合法对象并替换容器里的引用
        Automobile validCar = Automobile.createValid(this.carName);
        carContainer.set(validCar);
    }
}

3. 驱动类代码调整，使用引用容器 #

把car放到AtomicReference（或者自定义容器类）里，让catch块能通过异常的fix()方法修改它：

public class Driver {
    public static void main(String[] args) {
        String name = "car name";
        Double price = -222.00; // 非法价格，触发异常
        // 用AtomicReference作为容器，保存汽车对象引用
        AtomicReference<Automobile> carContainer = new AtomicReference<>();

        try {
            Automobile car = new Automobile(name, price);
            carContainer.set(car); // 构造成功就把对象放进容器
        } catch (CustomException e) {
            e.setCarContainer(carContainer); // 把容器传给异常
            e.fix(); // 调用fix替换容器里的对象
        }

        // 现在容器里就是合法的汽车对象了
        System.out.println("最终汽车对象：" + carContainer.get());
    }
}

为什么这样可行？ #

• 作用域问题解决：把car的容器声明在try/catch外面，catch块能访问到它。
• 引用传递特性：Java是值传递，但传递对象引用的副本时，异常类可以通过这个副本修改容器内部的对象引用（因为容器本身是对象，修改它的属性会影响外部）。
• 满足无返回值要求：fix()不需要返回任何值，直接修改外部容器里的对象即可。

替代方案：自定义容器类 #

如果你不想用AtomicReference，也可以自己写个简单的容器类：

class CarHolder {
    private Automobile car;

    public Automobile getCar() {
        return car;
    }

    public void setCar(Automobile car) {
        this.car = car;
    }
}

用法和AtomicReference完全一样，效果相同。

内容的提问来源于stack exchange，提问作者kurmanbek karaev