10. 注解与反射

10.2 反射

反射：动态引入类、动态调用实例的成员函数、成员变量等。

反射机制：动态加载一个类，动态的调用这个类的某个函数，动态的去修改这个类的成员变量，动态的调用他的构造函数

Calculator.java

package org.example.thirdparty;

public class Calculator {
    public String name;

    public Calculator() {
    }

    public Calculator(String name) {
        this.name = name;
    }
    public int add(int a,int b){
        return a+b;
    }

    public String greet(){
        return "Hi";
    }
    //toString()可以将这个类变成一个字符串
    public String toString(){
        return name;
    }
}

Main.java

package org.example;

import org.example.thirdparty.Calculator;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //加载类
        Class<?> cls=Class.forName("org.example.thirdparty.Calculator");
        //生成这个类的实例
        //通过无参构造函数得到类的一个实例
        Object o=cls.newInstance();//newInstance()调用的是Calculator类的一个无参构造函数

        //调用类里面的某个函数
        //得到函数，通过一个字符串来获取这个类的方法
        //动态执行新加入的类
        Method method=cls.getMethod("add", int.class, int.class);
        int res=(int)method.invoke(o,3,4);//invoke就是执行这个函数
        System.out.println(res);

        Method method1=cls.getMethod("greet");
        System.out.println(method1.invoke(o));//invoke就是执行这个函数

        //动态修改实例的成员变量
        //操作一个变量有两种方式，第一个是给他赋值，第二个是获取他的值
        Field field=cls.getField("name");
        field.set(o,"My Calculator!");//赋值，set某一个实例的某一个方法
        System.out.println(field.get(o));//获取变量值

        //调用一个有参构造
        //获取这个类的构造方法
        Constructor<?> constructor=cls.getConstructor(String.class);//写上参数的类型
        //生成一个新的实例
        Object new_o=constructor.newInstance("New Calculator!");
        System.out.println(new_o);


//        //静态写法
//        Calculator o=new Calculator();
//        //调用一个函数
//        System.out.println(o.add(3,4));
//        //改变一个变量值
//        o.name="My Calculator!";
//        //输出值
//        System.out.println(o.name);
//
//        //定义一个新的对象
//        Calculator newObject=new Calculator("New Calculator!");
//        System.out.println(newObject);

    }


}

11. 多线程与锁

用一个实例实现两个线程

package org.example;

class Worker implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("Hello!"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args){
        //用一个实例实现两个线程
        Worker worker=new Worker();
        new Thread(worker).start();
        new Thread(worker).start();
    }
}