回调与反射

1、回调机制：

//定义回调接口。
public interface Callback {
    void onCallback();
}

package com.callback;
//创建一个包含回调方法的类。
public class CallbackExample {
	
    public void longRunningProcess(Callback callback) {
        // 模拟长时间运行的任务
        try {
        	
            Thread.sleep(20000);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 运行完成后调用回调方法
        callback.onCallback();
    }
}

package com.callback;
//创建一个实现回调接口的类。
public class MyCallback implements Callback {
    @Override
    public void onCallback() {
        System.out.println("回调方法被调用");
    }
}

package com.callback;
//在主程序中使用回调。
//CallbackExample类的longRunningProcess方法接受一个Callback对象作为参数。
//在长时间运行的任务完成后，它将调用传递给它的Callback对象的onCallback方法。
//在Main类的主程序中，创建一个CallbackExample对象和一个实现了Callback接口的MyCallback对象。
//然后，将MyCallback对象传递给CallbackExample对象的longRunningProcess方法。
//当长时间运行的任务完成后，MyCallback对象的onCallback方法将被调用。
//这样就实现了一个简单的回调。
public class Main {
    public static void main(String[] args) {
        CallbackExample example = new CallbackExample();
        MyCallback callback = new MyCallback();

        example.longRunningProcess(callback);
    }
}

2、反射机制：

package com.callback;
//定义一个MyClass 类，它有两个构造方法：一个默认构造方法和一个带有一个 String 参数的构造方法。

//构造方法是用于创建对象时初始化对象的特殊方法。
//默认构造方法没有参数，它在对象创建时被自动调用，将name的值设置为"Default"。

//另一个构造方法接受一个String参数，用于自定义name的值。
//该构造方法将传入的name参数赋值给this.name。

//还有一个名为printName的方法，用于打印name的值。
//通过这些构造方法和方法，该类可以创建默认name值为"Default"的对象，或者创建具有自定义name值的对象，并能够打印出name的值。
class MyClass {
    private String name;

    public MyClass() {
        this.name = "Default";
    }

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

    public void printName() {
        System.out.println("Name: " + name);
    }
}

package com.callback;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//使用反射机制获取MyClass类的两个构造方法，并创建相应的实例对象。
//在主方法中，通过MyClass.class.getConstructor()方法获取默认构造方法的引用，
//并将其存储在Constructor<?>类型的变量constructor中。
//使用constructor.newInstance()方法通过默认构造方法创建了一个MyClass类的实例对象。
//由于newInstance()方法返回的是Object类型，需要进行类型转换为MyClass类型，并将其存储在MyClass类型的变量myClass中。
//通过myClass对象调用printName()方法，打印出name的值。
//重复类似的操作，获取带有一个String参数的构造方法的引用，并通过传递参数"Hello"创建另一个MyClass类的实例对象。
//使用反射机制获取构造方法的引用，并使用这些引用创建对象实例。
//通过这种方式，可以动态地在运行时创建对象，并使用其方法。
public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取 MyClass 类的默认构造方法
            Constructor<?> constructor = MyClass.class.getConstructor();
            // 创建对象实例
            Object obj = constructor.newInstance();
            // 调用对象方法
            MyClass myClass = (MyClass) obj;
            myClass.printName();

            // 获取 MyClass 类的带有一个 String 参数的构造方法
            constructor = MyClass.class.getConstructor(String.class);
            // 创建对象实例，传递参数
            obj = constructor.newInstance("Hello");
            // 调用对象方法
            myClass = (MyClass) obj;
            myClass.printName();

        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}