反射

1 什么是反射

• 反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法
• 一切反射相关的代码都从获得类（java.lang.Class）对象开始

• 实体类

package com.reflect.pyc;

public class Student {
	private String sid;

	private String sname;

	public Integer age;
	
	static{
		System.out.println("加载进jvm中！");
	}

	public Student() {
		super();
		System.out.println("调用无参构造方法创建了一个学生对象");
	}

	public Student(String sid) {
		super();
		this.sid = sid;
		System.out.println("调用带一个参数的构造方法创建了一个学生对象");
	}

	public Student(String sid, String sname) {
		super();
		this.sid = sid;
		this.sname = sname;
		System.out.println("调用带二个参数的构造方法创建了一个学生对象");
	}

	@SuppressWarnings("unused")
	private Student(Integer age) {
		System.out.println("调用Student类私有的构造方法创建一个学生对象");
		this.age = age;
	}

	public String getSid() {
		return sid;
	}

	public void setSid(String sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public void hello() {
		System.out.println("你好！我是" + this.sname);
	}

	public void hello(String name) {
		System.out.println(name + "你好！我是" + this.sname);
	}

	@SuppressWarnings("unused")
	private Integer add(Integer a, Integer b) {
		return new Integer(a.intValue() + b.intValue());
	}
}

• 通过三种类名的方式

1、Class.forName(“全路径名”);//jdbc/自定义mvc框架要用

	Class stucxk=Class.for Name("com.reflect.pyc.Student");

2.类名。class 结合泛型做通用分页查询方法会用

	Class stucxk=Class.forName("com.reflect.pyc.Student");

3。类实例的类实例getClass(蔡徐坤)获取 通用的增删改查结合泛型使用

	Student stu=new Student();
	Class stuCxk=stu.getClass();
	System.out.println(stuCxk);

ClassNotFoundException(类名错|少jar包)

同一类的、类对象只会创建一个

2.反射三大作用(java.lang.reflect.*)

实例化对象（c.newInstance() )
动态调用方法(Method m; m.invoke )
读写属性( Field set/get )

3.（1）实例化对象：
代码如下：

package com.reflect.pyc;

import java.lang.reflect.Constructor;

/**
 * 利用反射进行对象的通过实例化，通过new关键字进行实例化现在：通过java.lang.reflect.constructor
 *   之前：new关键字进行实例化
 *   现在：
 *       通过java.lang.reflect.construct来实例化对象
 *       
 * @author 96345
 *
 */
public class Demo2 {
   public static void main(String[] args) throws Exception, Exception {
   Student stu=new Student();
   Class stuCxk=stu.getClass();
   //注意：newInstance这个方法默认是使用无参构造器去实例化对象
   Student stu2=(Student) stuCxk.newInstance();
   System.out.println(stu2);
   
	
}
}

运行结果：

通过反射的方式调用带有一个参数的构造器来实例化对象

		Constructor<Student> constructor = stuClz.getConstructor(String.class);
		Student stu2 = (Student) constructor.newInstance("zs");

运行结果：

用两个参数的代码

		Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
		Student stu21 = (Student) constructor.newInstance("qq01","zs");
 

运行结果：

通过反射的方式调用私有的构造器来实例化对象 Class

Constructor<Student> constructor1 = stuClz.getDeclaredConstructor(Integer.class);
		constructor1.setAccessible(true);
		Student stu211 = (Student) constructor1.newInstance(18);

运行结果：

动态调用方法

package com.reflect.pyc;

import java.lang.reflect.Method;

public class kkk3 {
  public static void main(String[] args) throws Exception {
	  Student stu = new Student();
		Class<? extends Student> stuClz = stu.getClass();
		Method m= stuClz.getDeclaredMethod("hello");
		m.invoke(stu);
		}
}

运行结果：

第二种:传值

package com.reflect.pyc;

import java.lang.reflect.Method;

public class kkk3 {
  public static void main(String[] args) throws Exception {
	  Student stu = new Student();
		Class<? extends Student> stuClz = stu.getClass();
//		Method m= stuClz.getDeclaredMethod("hello");
//		m.invoke(stu);
		
		Method m= stuClz.getDeclaredMethod("hello",String.class);
		m.invoke(stu,"zs");
		
}
}

第三种：add方法

package com.reflect.pyc;

import java.lang.reflect.Method;

public class kkk3 {
  public static void main(String[] args) throws Exception {
	  Student stu = new Student();
		Class<? extends Student> stuClz = stu.getClass();
//		Method m= stuClz.getDeclaredMethod("hello");
//		m.invoke(stu);
		
//		Method m= stuClz.getDeclaredMethod("hello",String.class);
//		m.invoke(stu,"zs");
		
		Method m= stuClz.getDeclaredMethod("add",Integer.class,Integer.class);
		m.setAccessible(true);
		Method.invoke的返回值是被动态调用的方法的返回值
		Object invoke = m.invoke(stu,20,5);
		System.out.println(invoke);
		
}
}

运行结果：

3、读写属性

Field field=clz.getField(“属性名”);
field.getName(); -->获取属性名
filed.getType(); -->获取属性类型
field.getModifiers(); -->获取属性访问修饰符
field.set(Object,Object); -->设置属性值，参数1：要设置属性所在对象；参数2：要设置的值;
field.get(Object); -->获取属性值，参数：要获取属性值的对象
field.getDeclaredField(“属性名”); -->获取单个属性（私有、公有、受保护、默认、静态）
field.getDeclaredFields(); -->获取所有属性（私有、公有、受保护、默认、静态）

package com.reflect.pyc;

import java.lang.reflect.Field;

/**
 *  * 反射读写属性 自定义标签库、通用分页、自定义mvc也要用
 * 
 * 5. 访问修饰符
   getModifiers()
   	java:
   	private 1
   	protected 2
   	public 4
   	static 8
   	final abstract....
   	怎么判定属性或方法被那些修饰符所修饰呢？
   	getModifiers
   	3 private protected
   	5	
 * @author 96345
 *
 */
public class kkkk4 {
public static void main(String[] args) throws Exception {
	Student stu = new Student("s001", "zs");
	stu.age = 22;
	System.out.println(stu.getSid());
	System.out.println(stu.getSname());
	Class<? extends Student> stuClz = stu.getClass();


	//私有
    // Field f = stuClz.getDeclaredField("sname");
    // f.setAccessible(true);
    // System.out.println(f.get(stu));
	//共有
    // Field f = stuClz.getDeclaredField("age");
    // System.out.println(f.get(stu));

	// 获取当前Student实例中的stu所有属性及其属性值
	Field[] fields = stuClz.getDeclaredFields();
	for (Field field : fields) {
		field.setAccessible(true);
		System.out.println(field.getName() + ":" + field.get(stu));
	}
}
}

运行结果：

4.访问修饰符getModifiers()可以得到这个方法所修饰的修饰符

其中，该修饰符是java.lang.reflect.Modifier的静态属性。
对应表

PUBLIC: 1
PRIVATE: 2
PROTECTED: 4
STATIC: 8
FINAL: 16
SYNCHRONIZED: 32
VOLATILE: 64
TRANSIENT: 128
NATIVE: 256
INTERFACE: 512
ABSTRACT: 1024
STRICT: 2048

int java.lang.reflect.Field.getModifiers()
以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符

boolean java.lang.reflect.Modifier.isPublic(int mod)
如果整数参数包括 public 修饰符，则返回 true，否则返回 false