面向对象程序设计（异常，RTTI，泛型，动态加载）

异常

首先，我们知道Java中的异常分为两大类：编译时异常和运行时异常。编译时异常通常是一些在编写代码时就能发现的错误，比如文件找不到之类的；而运行时异常则是在程序运行过程中出现的，比如除零错误。

我们可以使用try和catch语句来捕捉异常，就像抱抱小猫一样抱住异常，然后给它一个温暖的处理过程。比如这样：

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // 可能会抛出异常的代码块
            int result = 10 / 0; // 这里故意制造一个除零异常
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            // 捕捉到异常后的处理
            System.out.println("哎呀，除数不能为零哦！ヽ(￣д￣;)ノ");
        }
    }
}

finally 代码块是用于确保在发生异常或者没有异常的情况下都能执行的一段代码。不管 try 代码块中是否发生了异常，finally 中的代码都会被执行。

RTTI：

在Java里，RTTI让你在运行时获取对象的类型信息，简直就像是给你一把魔法棒，让你能够探知对象的本质~?

Java中主要通过instanceof运算符和getClass()方法来实现RTTI。比如，如果你想知道一个对象是否是某个类的实例，可以这样写：

if (myObject instanceof MyClass) {
    System.out.println("嘿嘿，这个对象是我的类的实例哦！");
}

而如果想具体知道对象的类信息，可以使用getClass()方法：

Class<?> myClass = myObject.getClass();
System.out.println("这个对象的类是：" + myClass.getName());

这样，就能在运行时获取对象的类型信息啦~(＾?＾)/

泛型

在 Java 中，泛型提供了一种让你能够编写更加灵活、类型安全的代码的方式。

比如说，你可以创建一个泛型类来存储不同类型的数据。让我们来看一个简单的例子，比如一个泛型的盒子类：

public class Box<T> {
    private T content;

    public void put(T item) {
        this.content = item;
    }

    public T get() {
        return content;
    }
}

这样，你就能够创建一个能够盛放各种类型数据的盒子了！比如：

Box<String> stringBox = new Box<>();
stringBox.put("你好，泛型！");
System.out.println(stringBox.get());

Box<Integer> intBox = new Box<>();
intBox.put(42);
System.out.println(intBox.get());

动态加载

动态加载是指在程序运行时加载和使用类、模块或资源，而不是在编译时确定。这样的灵活性让我们的代码更加强大和可扩展哦！

在Java中，我们通常使用反射（Reflection）来实现动态加载。比如，你可以在运行时加载一个类，创建其实例，并调用其方法。这就为程序提供了更多的掌控权，可以根据需要动态地加载和使用不同的类。

try {
    // 动态加载类
    Class<?> dynamicClass = Class.forName("com.example.DynamicClass");
    
    // 创建类的实例
    Object instance = dynamicClass.newInstance();
    
    // 调用方法
    Method method = dynamicClass.getMethod("someMethod");
    method.invoke(instance);
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
    e.printStackTrace();
}

forName 是 Java 中用于动态加载类的一个方法！(＾?＾)/ 这个方法属于 Java 的反射（Reflection）机制，允许在运行时获取类的信息、调用类的方法，甚至创建类的实例。

forName要放在 try-catch 框架内，防止没找到导致的错误。

生成对象

在Java中，生成对象的操作通常涉及使用 `new` 关键字调用类的构造方法。以下是一些关于对象生成的常见操作：

1. **使用默认构造方法生成对象：**
? ? ```java
? ? MyClass myObject = new MyClass();
? ? ```

2. **使用带参数的构造方法生成对象：**
? ? ```java
? ? AnotherClass anotherObject = new AnotherClass(42);
? ? ```

3. **匿名对象的生成：**
? ? ```java
? ? new MyClass(); // 匿名对象，没有引用
? ? ```

4. **通过类字面常量获取 Class 对象：**
? ? ```java
? ? Class<?> myClass = MyClass.class;
? ? ```

5. **使用工厂方法生成对象：**
? ? ```java
? ? MyClass myObject = MyClass.createInstance(); // 在类中定义了一个静态的工厂方法
? ? ```

这些是一些基本的生成对象的操作。在实际应用中，根据具体的需求，还可以使用其他模式和技术，如单例模式、工厂模式、建造者模式等来生成对象。

其他

class Candy {
	public Candy() {print("test Candy");}
	static { print("Loading Candy"); }
}

调用时的结果为：

Loading Candy

test Candy
注意static { print("Loading Candy"); }的结果在前面。

Candy candy;不会有任何输出，candy 被声明但未被初始化。

new Candy();创建了 Candy 的对象，才会有输出。