JAVA基础35——反射

1.A:类的加载概述
当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化。
加载:就是指将class文件读入内存，并为之创建一个Class对象。 任何类被使用时系统都会建立一个Class对象。
连接:
验证：是否有正确的内部结构,并和其他类协调一致
准备：负责为类的静态成员分配内存，并设置默认初始化值
解析：：将类的二进制数据中的符号引用替换为直接引用
初始化:
B:加载时机
创建类的实例
访问类的静态变量,或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java. lang.Class对象
初始化某个类的子类
直接使用java . exe命令来运行某个主类
2.A:类加载器的概述
负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
B:类加载器的分类
Bootstrap ClassLoader 根类加载器
Extension ClassLoader扩展类加载器
Sysetm ClassLoader 系统类加载器
C:类加载器的作用
Bootstrap ClassLoader 根类加载器，也被称为引导类加载器，负责Java核心类的加载
比如System ，String等。在JDK中JRE的1ib目录下rt jar文件中。
Extension ClassLoader 扩展类加载器，负责JRE的扩展目录中jar包的加载。在JDK中JRE的lib目录下ext目录
Sysetm ClassLoader 系统类加载器，负责在JVM启动时加载来自java命令的Class文件，以及classpath环境变量所指定的jar包和类路径。
3.
A:.反射概述
JAVA反射机制是在运行状态中,对于任意-个类,都能够知道这个类的所有属性和方法;
对于任意-个对象，都能够调用它的任意一个方法和属性 ;
这种动态获取的信息以及动态调用对象的方法的功能称为j ava语言的反射机制。
要想解剖-个类,必须先要获取到该类的字节码文件对象。
而解剖使用的就是Class类中的方法,所以先要获取到每一 个字节码文件对应的Class类型的对象。
B:三种方式
a:0bject类的getClass()方法 ,判断两个对象是否是同一个字节码文件
b:静态属性class ,锁对象
C:Class类中静态方法forName(), 读取配置文件

public class Demo1Reflect {

	/**
	 * @param args
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		Class c1 = Class.forName("com.guada.reflect.Person");
		Class c2 = Person.class;
		
		Person p = new Person();
		Class c3 = p.getClass();
		
		System.out.println(c1 == c2);
		System.out.println(c2 == c3);
	}

}

public class demo2 {

	/**
	 * class.forName()读取配置文件
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader("config.properties"));
		Class c = Class.forName(br.readLine());
		Animal a = (Animal) c.newInstance();
		Shop s = new Shop();
		s.ShopAnimal(a);
	}

}

interface Animal{
	public void eat();
}
class Cat implements Animal{
	public void eat(){
		System.out.println("养一只小猫，猫吃鱼");
	}
}

class Dog implements Animal{
	public void eat(){
		System.out.println("养一只小狗，狗吃肉");
	}
}

class Shop{
	public void ShopAnimal(Animal a){
		a.eat();
	}
}

配置文件内容：

5.

public class Demo3 {
	/*
 Class类的newInstance ()方法是使用该类无参的构造函数创建对象，如果-个类没有无参的构造函数,
就不能这样创建了,可以调用Class类的getConstructor
(String. class, int. class)方法获取一个指定的构造函数然后再调用Const ructor类的newInstance
("张三”", 20)方法创建对象


Class .getField (String)方法可以获取类中的指定字段(可见的)，
如果是私有的可以用getDeclaedField ("name")方法获取,通过set (obj，"李四") 方法可以设置
指定对象上该字段的值,
如果是私有的需要先调用setAccessible (true)设盟访问权限，用获取的指定的字段调用get (obi )可以获取指定对象中该字段的
值
	 * */
public static void main(String[] args) throws Exception {
	Class c1 = Class.forName("com.guada.reflect.Person");
	Constructor  con1 = c1.getConstructor(String.class,int.class);     //获取有参构造
	
	Person p = (Person) con1.newInstance("张三",23);             //通过有参构造创建对象
	Field f = c1.getDeclaredField("name");
	f.setAccessible(true);
	f.set(p, "ss");
	System.out.println(p.getName());                        
}
}

public class DemoMethed {

	/**
	 * 1.通过反射获取方法并使用：
	 * ★Class .getMethod (String，Class...) 和Class.getDeclaredMethod (String,
Class.. .)方法可以获取类中的指定方法，调用invoke (object,
object. . .)可以调用该方法,Class. getMethod("eat") invoke (0bi)
Class. getMethod("eat", int.class) invoke (obi, 10)

	 * 2.通过反射越过泛型检查:
	 * ArrayList< Integer>的一个对象,在这个集合中添加一个字符串数据,如何实现呢?
		泛型只在编译期有效，在运行期会被擦除掉。
	 * 	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		Class c1 = Class.forName("com.guada.reflect.Person");
		Constructor con = c1.getConstructor(String.class,int.class);
		Person p = (Person) con.newInstance("ss",23);
		
		//med(c1, p);
		
		demo2();
		
	}

	public static void demo2() throws ClassNotFoundException,
			NoSuchMethodException, IllegalAccessException,
			InvocationTargetException {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(111);
		list.add(222);
		
		Class c2 = Class.forName("java.util.ArrayList");
		Method m = c2.getMethod("add", Object.class);
		m.invoke(list, "adc");
		System.out.println(list);
	}

	public static void med(Class c1, Person p) throws NoSuchMethodException,
			IllegalAccessException, InvocationTargetException {
		Method m = c1.getMethod("eat");
		m.invoke(p);
	}

}

7.动态代理

public class test {

	/**
	 * A:动态代理概述
代理:本来应该自己做的事情,请了别人来做,被请的人就是代理对象。
举例:春节回家买票让人代买
*动态代理:在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容,所以,动态代理其实就是通过反射来生成一-个代理
在Java中java.lang. reflect包下提供了一-个Proxy类和- -个InvocationHandler接口, 通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理
cglib , Proxy类中的方法创建动态代理类对象
public_ static object newProxyInstance(ClassLoader loader ,Class<?>[] interfaces , InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler object invoke(object proxy,Method method,object[] args)

	 * @param args
	 */
	public static void main(String[] args) {
		StudentImp si = new StudentImp();
		si.register();
		si.login();
		System.out.println("---------------------");
		Myinvoke m = new Myinvoke(si);
		Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m);
		s.register();
		s.login();
		
	}

}

public class Myinvoke implements InvocationHandler {
	private Object target;
	public Myinvoke(Object target){
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("权限校验");
		method.invoke(target, args);           //执行被代理对象的方法
		System.out.println("日志记录");
		return null;
	}

}

public interface Student {
	public void register();
	public void login();
}

public class StudentImp implements Student {

	@Override
	public void register() {
		System.out.println("注册功能");
	}

	@Override
	public void login() {
		System.out.println("登陆功能");
	}

}