java反射与类加载

//final修饰的常量变为宏常量。在下面进行编译时会自动进行替换成他的值，即使静态的代码块也不会执行，下面初始化不会打印出来
class test{
	static{
		System.out.println("初始化");
	}
	static final String str="java疯狂讲义";
}
class test1{
	public static void main(String[] args) {
		System.out.println(test.str);
	}
}

当某个静态变量用final修饰后，在后面调用时实际就是当常量。

类的加载分为加载。连接，初始化

加载：类加载器负责加载所有的类，系统为所有加载的类创建一个java.lang.class实例，一旦一个类被加载进jvm同一个类不会被再次载入。

连接：验证内部结构，和其他类协调一致。准备：为静态成为分配内存。解析：将类的二进制数据转化为引用。

根加载器：java核心类的加载，jre lib文件夹下rt.jar

扩展加载器:jre lib目录ext包下

系统加载器：系统调用jvm时的加载的类与classpath路径下的jar包与类。

java反射机制在运行中，可以获得任意类中任意的方法与成员。可以通过反射传入配置文件的字符串达到反射的效果。

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

class test {
      public static void main(String[] args) throws Exception {
		
	
	//获取字节码文件
	Class c = Class.forName("person");
//	//获取无参构造，也可以通过getdeclareConstructors暴力获取私有构造。
//	Constructor constructor = c.getConstructor(null);
//	//创建实例
//	Object newInstance = constructor.newInstance(null);
//	System.out.println(newInstance);
//       Constructor constructor = c.getConstructor(int.class);
//	//创建实例
//       Object newInstance = constructor.newInstance(20);
//       System.out.println(newInstance);
       //访问私有构造方法
//	Constructor declaredConstructor = c.getDeclaredConstructor(int.class,String.class);
//	declaredConstructor.setAccessible(true);//访问私有的属性都要打开true
//	Object newInstance = declaredConstructor.newInstance(20,"张三");
//	System.out.println(newInstance);
       //获取成员变量
//	Field field = c.getField("age");
//	//必须获得对象实例。调用无参构造
//	Constructor constructor = c.getConstructor(null);
//    //创建实例
//	Object newInstance = constructor.newInstance(null);
//	field.setInt(newInstance, 20);
//	System.out.println(newInstance);
	//获取方法
	Constructor constructor = c.getConstructor(null);
    //创建实例
	Object newInstance = constructor.newInstance(null);
	Method method = c.getMethod("show");
	method.invoke(newInstance);
}
}

动态代理，主要是用在给一些代码嵌入，或抽取相同的代码。解耦合。

package proxy;

public interface dog {
     void run();
    void eat();
}
package proxy;

public class dogimp implements dog {

	@Override
	public void run() {
		System.out.println("跑的快");
	}

	@Override
	public void eat() {
		System.out.println("吃的多");
	}

}

public class dogutil {
public void method1(){
	System.out.println("功能增强1");
}
public void method2(){
	System.out.println("功能增强2");
}
}
package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class myinvokehandler implements InvocationHandler {
     //需要被代理的对象
	private Object target;
	public void setTarget(Object target){
		this.target=target;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		dogutil d=new dogutil();//需要抽取或者嵌入的代码
		d.method1();
		Object invoke = method.invoke(target, args);//本质自身将自身方法与对象绑定
		d.method2();
		return invoke;//返回增强对象
	}

}
package proxy;

import java.lang.reflect.Proxy;

public class test {
public static void main(String[] args) {
	dog d=new dogimp();
	myinvokehandler myhandler=new myinvokehandler();
	myhandler.setTarget(d);
	Object newProxyInstance = Proxy.newProxyInstance(d.getClass().getClassLoader(),d.getClass().getInterfaces() , myhandler);
	dog dq=(dog)newProxyInstance;
	dq.eat();
	dq.run();
}
}