// java
import java.lang.reflect.Field;

public class DynamicFieldExample {
    /**
     * 什么是 throws Exception？
     * throw Exceptions到方法的调用者，告诉调用者这个方法可能会抛出某些异常
     * 什么时候需要 throws Exception？
     * 当方法内部可能会抛出异常，但是方法本身不处理异常时，且异常为checked exceptions
     * 时必须需要在方法签名中声明 throws Exception
     * 注意，这里的Exception是所有exceptions的父类，你可以用任何继承该类的异常替换
     * runtime exceptions 即运行时发生的错误 继承 unchecked exceptions 不需要在
     * 方法签名中声明 throws Exception
     * 这是因为未检查异常通常表示编程错误，如逻辑错误或不正确的 API 使用，而不是可以合理预期和恢复的情况。
     * 你开发的时候就要修复这些错误，而不是想着在运行时处理他们。
     */
    public static void main(String[] args) throws Exception {
        // 创建一个实例
        MyClass obj = new MyClass();

        // 通过对象实例（obj）获取类对象
        Class<?> clazz = obj.getClass();

        // 动态添加字段，Field 类表示类或接口的一个字段（成员变量）。通过 Field 对象，
        // 可以获取字段的元数据（如字段名、类型等），并可以动态地访问和修改字段的值。
        Field field = clazz.getDeclaredField("age");
        field.setAccessible(true);
        field.set(obj, 30);

        // 访问动态添加的字段
        int age = (int) field.get(obj);
        System.out.println("Age: " + age);
        // 输出: Age: 30，哈哈，有没有发现private字段也能访问修改，so cool！
        // 其实嘛，访问修饰符主要作用还是让开发者知道这个字段该不该访问，该不该修改，从java的角度完全限制访问是不可能的
    }
}

class MyClass {
    private int age;
}

//java
public class Main {
    public static void main(String[] args) {
        try {
            int a = 1 / 0;
        } catch (Exception e) {
            System.out.println("发生异常：" + e);
        }
    }
}

# python
try:
    a = 1 / 0
except Exception as e:
    print("发生异常：", e)
# Exception被用作通配符(wild card),为不想指定异常时捕获所有异常
# 这里是所有非致命异常的基类（不是Exception 的子类的异常通常不被处理，因为它们被用来指示程序应该终止）

# 发生异常： division by zero

try:
    a = 1 / 0
except ZeroDivisionError as e:
    print("发生异常：", e)

# except后为你想要捕获的异常类型，你可以指定多个异常类型，用逗号分隔（ 其实是元组），
# 发生异常： division by zero

class B(Exception):
    pass

class C(B):
    pass

class D(C):
    pass

for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

>>> try:
        raise Exception('spam', 'eggs')
>>> except Exception as inst:
        print(type(inst))    # the exception type
        print(inst.args)     # arguments stored in .args
        print(inst)          # __str__ allows args to be printed directly,
                            # but may be overridden in exception subclasses
        x, y = inst.args     # unpack args
        print('x =', x)
        print('y =', y)
# output:
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error:", err)
except ValueError:
    print("Could not convert data to an integer.")
except Exception as err:
    print(f"Unexpected {err=}, {type(err)=}")
    raise

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error:", err)
except ValueError:
    print("Could not convert data to an integer.")
except Exception as err:
    print(f"Unexpected {err=}, {type(err)=}")
    raise
else:
    print("No exceptions were raised.")
finally:
    print("This will always be executed, whether an exception was raised or not.")
    try:
        f.close()
    except NameError:
        pass  # f was never opened

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    raise

>>> try:
        open("database.sqlite")
>>> except OSError:
        raise RuntimeError("unable to handle error")

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: unable to handle error

>>> def func():
        raise ConnectionError

>>> try:
        func()
>>> except ConnectionError as exc:
        raise RuntimeError('Failed to open database') from exc

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
ConnectionError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

>>> def f():
        excs = [OSError('error 1'), SystemError('error 2')]
        raise ExceptionGroup('there were problems', excs)

>>> f()
    + Exception Group Traceback (most recent call last):
    |   File "<stdin>", line 1, in <module>
    |   File "<stdin>", line 3, in f
    | ExceptionGroup: there were problems
    +-+---------------- 1 ----------------
        | OSError: error 1
        +---------------- 2 ----------------
        | SystemError: error 2
        +------------------------------------
>>> try:
        f()
    except Exception as e:
        print(f'caught {type(e)}: e')

    caught <class 'ExceptionGroup'>: e

def f():
    raise ExceptionGroup(
        "group1",
        [
            OSError(1),
            SystemError(2),
            ExceptionGroup(
                "group2",
                [
                    OSError(3),
                    RecursionError(4)
                ]
            )
        ]
    )

try:
    f()
except* OSError as e:
    print("There were OSErrors")
except* SystemError as e:
    print("There were SystemErrors")

There were OSErrors
There were SystemErrors
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 2, in <module>
  |   File "<stdin>", line 2, in f
  | ExceptionGroup: group1
  +-+---------------- 1 ----------------
    | ExceptionGroup: group2
    +-+---------------- 1 ----------------
      | RecursionError: 4
      +------------------------------------

excs = []
for test in tests:
    try:
        test.run()
    except Exception as e:
        excs.append(e)

if excs:
   raise ExceptionGroup("Test Failures", excs)

try:
    raise TypeError('bad type')
except Exception as e:
    e.add_note('Add some information')
    e.add_note('Add some more information')
    raise

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: bad type
Add some information
Add some more information