Class类：Class的实例就对应着一个运行时类
获取Class的实例的方式：
方式一：调用运行时类的属性（.class）
Class clazz = Person.class; System.out.println(clazz);
方式二：通过运行时的对象，调用getClass（）方法
Person p1=new Person(); Class clazz2 =p1.getClass(); System.out.println(clazz2);
方式三：调用Class的静态方法，forName(String classPath)（用的多）
Class clazz3 = Class.forName("Person");
System.out.println(clazz3);
clazz1 clazz2 clazz3地址值相同，为同一个运行时类
补充：只要数组的元素类型和维度一样，就是同一个Class
Properties：读取配置文件
方式一：
方式二：
通过反射创建对应运行时类的对象：
newInstance（）：调用此方法，创建对应的运行时类的对象，内部调用空参构造器
public void test1() throws InstantiationException, IllegalAccessException {
Class clazz=Person.class;
Person o = clazz.newInstance();
System.out.println(o);
}
此方法正常运行要求：
1.运行时类必须具有空参构造器
2.空参构造器访问权限为public（或可以访问的到的）
动态调用：
调用运行时类中指定的结构：属性，方法，构造器
属性：
方法：
调用静态方法：invoke（Person.class）
如果调用方法没有返回值，则invoke返回null
构造器：
静态代理：代理类和被代理类在编译期间就被确定下来了
动态代理：例子：
//接口
interface Human{
void eat(String food);
String getbriefe();
}
//被代理类
class SuperMan implements Human{
@Override
public void eat(String food) {
System.out.println("我喜欢吃"+food);
}
@Override
public String getbriefe() {
System.out.println("我有信仰");
return "我有信仰";
}
}
//动态代理
class ProxyFactory{
//调用此方法返回代理类对象
public static Object getProxyFactory(Object obj){
MyInvocationHandler invocationHandler = new MyInvocationHandler();
invocationHandler.bind(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),invocationHandler);
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj;
public void bind(Object obj){
this.obj=obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(obj, args);
return invoke;
}
}
public class ProxyTest {
public static void main(String[] args) {
SuperMan sp = new SuperMan();
Human proxyFactory = (Human)ProxyFactory.getProxyFactory(sp);
proxyFactory.getbriefe();
proxyFactory.eat("aaa");
}
}
