使用Super传递父类异常字符串，为什么子类对象的getMessage无法返回信息

在 Java 中，当一个异常被抛出时，它会被传递到调用堆栈中的第一个 catch 块中，如果该 catch 块没有处理该异常，则该异常会被传递到下一个 catch 块中，依此类推，直到异常被处理或者程序终止。

在 Super 语句中，如果子类继承了父类的异常，并且在子类中使用了 Super 语句调用父类的异常构造器时，父类的异常构造器会被调用，并且可以将异常信息传递到子类中。

当子类中调用 getMessage 方法时，它会首先查看自己是否有异常信息，如果有则返回自己的异常信息，否则会调用父类的 getMessage 方法获取异常信息。但是，如果父类的构造器中没有传递异常信息，那么子类中调用 getMessage 方法时就无法返回异常信息。

因此，如果想在子类中获取父类异常的信息，需要在父类的异常构造器中传递异常信息，否则子类中调用 getMessage 方法时就无法获取异常信息。

相关问题

写一个包含类的封装，get/set方法。 包含构造方法和构造方法的重载。 包含继承，方法重写。 包含抽象类和接口。 包含异常处理机制。 包含自定义异常。 包含super，final关键字。 包含多态。 包含4个字符串处理方法。 包含选择语句和循环语句。

好的，下面是一个简单的示例代码：

// 抽象类
abstract class Animal {
    // 抽象方法
    public abstract void sayHello();
}

// 接口
interface Flyable {
    void fly();
}

// 自定义异常
class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

// 父类
class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public final void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

// 子类
class Student extends Person implements Flyable {
    private int grade;

    public Student(String name, int grade) {
        super(name);
        this.grade = grade;
    }

    // 重写方法
    @Override
    public void sayHello() {
        System.out.println("Hi, I'm a student and my name is " + super.name + ", and my grade is " + grade);
    }

    // 实现接口方法
    @Override
    public void fly() {
        System.out.println("I'm flying");
    }
}

// 字符串处理方法
class StringUtil {
    public static String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }

    public static String toUpperCase(String str) {
        return str.toUpperCase();
    }

    public static String toLowerCase(String str) {
        return str.toLowerCase();
    }

    public static String trim(String str) {
        return str.trim();
    }
}

public class Demo {
    public static void main(String[] args) {
        // 创建对象
        Student student = new Student("Tom", 3);

        // 调用方法
        student.sayHello();
        student.fly();

        // 字符串处理方法
        String str = " Hello, World! ";
        System.out.println(StringUtil.reverse(str));
        System.out.println(StringUtil.toUpperCase(str));
        System.out.println(StringUtil.toLowerCase(str));
        System.out.println(StringUtil.trim(str));

        // 异常处理
        try {
            int i = 1 / 0;
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }

        try {
            throw new MyException("自定义异常");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }

        // 选择语句和循环语句
        int num = 3;
        if (num > 0) {
            System.out.println(num + "是正数");
        } else if (num < 0) {
            System.out.println(num + "是负数");
        } else {
            System.out.println(num + "是0");
        }

        for (int i = 1; i <= 10; i++) {
            System.out.print(i + " ");
        }

        int i = 1;
        while (i <= 10) {
            System.out.print(i + " ");
            i++;
        }
    }
}

以上代码演示了如何实现一个包含类的封装、get/set方法、构造方法和构造方法的重载、继承、方法重写、抽象类、接口、异常处理机制、自定义异常、super、final关键字、多态、字符串处理方法、选择语句和循环语句的示例程序。

orElseThrow()抛出的异常必须是空指针异常类或者空指针异常的子类吗?可以是自定义的类吗?如果我先使用Optional.ofNullable()规避了空指针异常后,我在orElseThrow()传入的参数是其他的异常, 可以吗

`orElseThrow()` 方法的参数可以是任何类型的异常，不限于空指针异常类或其子类。你完全可以传入自定义的异常类作为参数。

`orElseThrow()` 方法接受一个 `Supplier` 函数接口作为参数，用于在需要时创建并抛出异常。`Supplier` 函数接口表示一个供应商，它不接受任何参数，返回一个结果。在这种情况下，它用于提供异常对象。

以下是一个示例代码，演示了如何在 `orElseThrow()` 方法中使用自定义异常类：

import java.util.Optional;

public class Example {
    public static void main(String[] args) {
        String value = null;

        try {
            String result = Optional.ofNullable(value)
                    .orElseThrow(() -> new MyCustomException("Value cannot be null"));
            System.out.println(result);
        } catch (MyCustomException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

在上述代码中，我们创建了一个空值的字符串 `value`。然后，我们使用 `Optional.ofNullable(value)` 将其封装到一个 `Optional` 对象中。

接着，我们在 `orElseThrow()` 方法中使用 `Supplier` lambda 表达式创建并抛出一个自定义异常类 `MyCustomException` 的实例。

如果 `value` 为空，则会抛出 `MyCustomException` 异常，并在 catch 块中捕获该异常并输出相应的消息。

所以，你可以在 `orElseThrow()` 方法中传入任何类型的异常类，包括自定义的异常类，以满足你的需求。