javaweb-reflect_反射

java中反射解析：

反射：框架设计的灵魂
 * 	框架：半成品软件，可以在框架的基础上进行软件的开发，简化代码的操作
 * 	反射：将类的各个组成部分封装成其他对象，这就是反射机制
 * 		好处：可以在程序的运行过程中，操作这些对象
 * 			可以解耦，提高程序的可扩展性
 * 类的组成部分：
 * 		成员方法   成员变量   构造方法
 * Java代码的三个阶段   :
 * 源代码（编译阶段class字节码文件阶段）
 * class类对象阶段  （已经记载进入了内存）
 * 创建对象的阶段  （RunTime运行阶段）
 * 
 * 
 * 每个阶段的获取class对象的方式不一样
 * 		源代码阶段---》classForName("全类名")，没有加载进内存时
 * 		class类对象阶段-->类名.class--》通过类名的属性进行获取
 * 		创建对象阶段--》对象名.getClass()--》通过对象名进行获取类的对象
 * 
 * 
 * 注意：同一个字节码文件（*.class）只会加载进内存一个
 * 
 *Class对象的功能：既然类的各个组成部分已经被封装好了，那么就应该是类的对象来获取类的各个组成部分


**//获取class对象的方式**

```java
public static void main(String[] args) throws Exception {
		
		//1.Class.ForName("全类名")
		Class cls=Class.forName("cn.tedu.domain.Person");
		System.out.println(cls);
		//2.加载进入内存后的  类名.class
		Class cls1=Person.class;
		System.out.println(cls1);
		//3.对象名.getClass()
		Person p=new Person();
		Class cls2=p.getClass();
		System.out.println(cls2);
		
		//验证是否同一个class文件只会进行加载进内存一次
		System.out.println(cls1==cls);
		System.out.println(cls1==cls2);
		System.out.println(cls2==cls);
		
		
		
		
		
		
	}
	**//获取成员变量对象的方式**
	

```java

	public static void main(String[] args) throws Exception{
		
		//进行Class对象的使用-->获取要拿到的Class对象
		Class cls=Person.class;
		//1.对成员变量的使用---》不限定所有的权限控制.不考虑修饰符的作用状况
		Field[] fields=cls.getDeclaredFields();
		for(Field field:fields){
			System.out.println(field);
		}
		
		System.out.println("-------------");
		//只会获取public 修饰符的状态
		//Field f=cls.getField(null);
		/*f.setAccessible(true);//暴力反射获取
		System.out.println("f"+f);*/
		Field f=cls.getField("age");
		Person p=new Person();
		Object value = f.get(p);
		System.out.println("value"+value);
		//暴力进行获取
		Field f1=cls.getDeclaredField("age");
		//f1.setAccessible(true);
		System.out.println(f1);
		
		System.out.println("------------");
		
	
		
	}
	**//获取构造方法和成员方法的方式**
```java
public static void main(String[] args) throws Exception{
		
		//进行Class对象的使用-->获取要拿到的Class对象
		Class<Person> cls=Person.class;
		//1.操作成员方法  获取所有的方法，有从Object中继承的方法
		Method[] methods = cls.getMethods();
		for(Method method:methods){
			System.out.println(method);
		}
		
		System.out.println("------1-------");
		
		//1.1  方法中没有参数的不需要指定参数的关系
		Method method = cls.getMethod("eat");
		method.invoke(new Person());
		System.out.println(method);
		System.out.println("------2-------");
		//获取所有的声明的方法，不限制权限的作用
		Method[] declaredMethods = cls.getDeclaredMethods();
		for(Method declaredMethod:declaredMethods){
			System.out.println(declaredMethod);
		}
		System.out.println("constructor");
		
		//2.构造方法的获取-->反射中通过构造方法直接new出一个对象
		Constructor<?>[] constructors = cls.getConstructors();
		for(Constructor constructor:constructors){
			System.out.println(constructor);
		}
		
		System.out.println("1111111111111111111");
		//获取无参构造方法
		Constructor<Person> constructor = cls.getConstructor();
		System.out.println("hahah "+constructor);
		
		System.out.println("22222222222222222");
		//简便方式在内存反射中创建对象
		Person newInstance = cls.newInstance();
		System.out.println(newInstance);
		//通过构造方法创建反射的对象       newInstance（）方法只能进行无参构造的函数
		Person newInstance2 = constructor.newInstance();
		System.out.println(newInstance2);
		System.out.println(newInstance==newInstance2);
		String name = cls.getName();//获取的是全限定类名
		String simpleName = cls.getSimpleName();
		System.out.println(name);
		System.out.println(simpleName);
		
		
		
	}
	

注意:暴力反射————》对象名.setAccess(true),实现跳过private和public权限执行