反射

1.什么是反射

反射是java语言中的一种机制，通过机制可以动态的实例化对象，读写属性、调用方法

反射的优点

反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创和控制任何类的对象，无需提前硬编码目标类

反射的缺点

性能问题，使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用

2. 类类

所有狗 狗类 Dog 狗对象 旺财
所有猫 猫类 Cat 猫对象 肥波
所有类 类类 java.lang.Class 类对象 特定类

java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.construct

(Dog.java , Cat.java…).java文件我们能不能描述成一种事物呢？
java.lang.Class这个类就是描述Dog.java,Cat,java这些东西的
具体的.java文件就是描述java.lang.Class这个类的一个具体的实例

类组成部分：
类属性 java.lang.reflect.Field (都是以java面向对象的思想对它进行封装了)
类方法 java.lang.reflect.Method

3.一切反射相关的代码都从获得java.lang.Class类对象开始

3.1 Class.forName(完整类名)
3.2 类名.class
3.3 对象.getClass()

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

4.1获取类对象的三种方式

代码演示：
创建一个Student类

package com.myy.reflect;

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());
	}
}

Demo1:

package com.myy.reflect;

/**
 * 获取类对象的方式
 *  通过java提供的反射机制获取到com.myy.reflect.Student.class
 *  1.Class.forName("全路径名");   jdbc/自定义mvc框架调用
 *  2.类名.class 结合泛型做通用分页查询方法会用
 *  3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取  通用的增删改结合泛型使用
 *  
 * @author myy
 *
 */
public class Demo1 {
  public static void main(String[] args) throws Exception {
//	 1.Class.forName("全路径名");   jdbc/自定义mvc框架调用
	Class stuClz = Class.forName("com.myy.reflect.Student");
	System.out.println("------------");
	
//	 2.类名.class 结合泛型做通用分页查询方法会用
	Class stuClz1 = Student.class;
	System.out.println(stuClz1);
	System.out.println("-------------");
	
	Student stu = new Student();
//	3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取  通用的增删改结合泛型使用
	Class stuClz2 =  stu.getClass();
	System.out.println(stuClz2);//并且还调用了无参构造器
	
	
}
	
}

运行结果：

4.2反射实例化对象

代码演示：
Demo2:

package com.myy.reflect;

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

运行结果：

提问：假设没有无参构造器运行会不会报错
代码演示：
首先，先把Student类的无参构造器注释掉

然后，修改一下Demo2的代码

 public static void main(String[] args) throws Exception, Exception {
//		Student stu = new Student();
//		Class stuClz = stu.getClass();
    	Class stuClz = Student.class;
//		newInstance这个方法默认是使用无参构造器去实例化对象
		Student stu2 = (Student) stuClz.newInstance();
		System.out.println(stu2);//如果不是空就意味着创建出来
	}

如图所示运行会报错：

答：由上面代码演示我们得知当没有无参构造器的时候运行会报错。
运行报错的原因是：没有找到匹配方法，因为它默认找的是默认无参构造器。
注意：一定要提供无参构造器

优势：

1. 能够对未知的对象进行实例化
2. 能够对私有的构造器实例化对象

1.1代码演示：

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//		调用有参构造器去实例化对象
    	Constructor<Student> constructor = stuClz.getConstructor(String.class);
    	Student stu2 = (Student)constructor.newInstance("张三");
    	
	}

运行结果：

1.2代码演示

public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//		调用有参构造器去实例化对象(两个参数的)
    	Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
    	Student stu2 = (Student)constructor.newInstance("t003","张三");
    	
	}

运行结果：

2.1如果按照以上的操作进行代码演示

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz.getConstructor(Integer.class);
    	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果：

getConstructor与getDeclaredConstructoe的区别
getConstructor只能获取被public修饰的构造器
getDeclaredConstructoe被所有关键字修饰的构造器

所以私有的要用getDeclaredConstructoe

如代码演示:

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
    	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果：

Class com.myy.reflect.Demo2 can not access a member of class com.myy.reflect.Student with modifiers "private"

该错误原因是：找到了私有的构造器，但不能调用因为没有权限

则要对代码进行给予权限如代码演示：

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
constructor.setAccessible(true);//默认为false    
	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果：

4.3 反射动态调用方法

Demo3:
无参的代码演示：

package com.myy.reflect;

import java.lang.reflect.Method;

/**
 * 动态方法调用
 *  构造方法是不是方法
 * 
 * @author myy
 *
 */
public class Demo3 {
 public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
//无参
	Method m= stuClz.getDeclaredMethod("hello");
	m.invoke(stu);
}
}

运行结果：

有参的代码演示：

public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
	//有参的
	Method m= stuClz.getDeclaredMethod("hello", String.class);
	m.invoke(stu, "张三");
}

运行结果：

私有的代码演示：

 public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
	//私有的
	Method m = stuClz.getDeclaredMethod("add", Integer.class,Integer.class);
   m.setAccessible(true);
	//	Method.invoke的返回值是被动态调用的方法的返回值
	Object invoke = m.invoke(stu, 11,9);
	System.out.println(invoke);
}

运行结果：

4.4 反射读写属性

Demo4:
代码演示：

package com.myy.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 *  自定义标签库，通用分页，自定义mvc也要用
 * @author myy
 *
 */
public class Demo4 {
public static void main(String[] args) throws Exception {
	Student stu = new Student("t003","张三");
	stu.age = 18;
	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));
	
//	获取当前Student实例中的stu私有属性及其属性值
	Field[] fields = stuClz.getDeclaredFields();
	for (Field field : fields) {
		field.setAccessible(true);
		System.out.println(field.getName()+":"+field.get(stu));
	}
}
}

运行结果：

5.访问修饰符

如何判断类或变量、方法的修饰符，可以使用Java反射机制中，Field的 getModifiers() 方法返回int类型值表示该字段的修饰符，

即这个方法就是返回一个int型的返回值，代表类、成员变量、方法的修饰符。

该修饰符是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

Modifier提供了很多静态方法，对类和成员访问修饰符进行解码。
如代码演示：

package com.myy.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 *   Modifier.isAbstract(int mod) 
 *   Modifier.isFinal(int mod) 
 *   Modifier.isInterface(int mod)
 *   Modifier.isNative(int mod)
 *   Modifier.isPrivate(int mod)
 *   Modifier.isProtected(int mod) 
 *   Modifier.isStatic(int mod)
 *   Modifier.isStrict(int mod)
 *   Modifier.isSynchronized(int mod)  
 *   Modifier.isTransient(int mod)
 *   Modifier.isVolatile(int mod) 
 *   
 * @author myy
 *
 */
public class Demo5 {
public static void main(String[] args) {
     Field[] fileds = Student.class.getDeclaredFields();
     for (Field field : fileds) {
		System.out.println(field.getName()+"  访问修饰符是否包括private:"+Modifier.isPrivate(field.getModifiers()));
	    System.out.println(field.getName()+"  访问修饰符是否包括static:"+Modifier.isStatic(field.getModifiers()));
	    System.out.println(field.getName()+"  访问修饰符是否包括public:"+Modifier.isPublic(field.getModifiers()));
     }
}
}

运行结果：