目录
今天与大家分享的是：反射，大多数时候我们不能直接拿到一个类的实例，而今天我跟大家分享反射之后，就能通过反射来拿到对象了。
一：反射
1、定义：反射是JAVA语言中一种机制通过该机制可以动态的实例化对象，读取属性，以及调用方法。
2、为什么要学反射？
java的反射机制就是增加程序的灵活性，避免将程序写死到代码里。
二：类类
1、什么是类类？
我将用一个列子来解释什么是类类，比如有一个类叫狗类，狗类的有一个实例化的列子是叫旺财，所以说旺财是狗类的一个实例化例子，而狗类又是Class的实例化例子。所以说Class是类类。
2、类类的类对象的三种获取方式：
这里我先拿 学生类 作为案例为大家讲解：
package com.ycx.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());
}
}
1、类名.class（）（以后是要作通用查询）
//1、类.class
Class clz1=Student.class;
2、类实例.getClass()
//2、类实例.getClass()
// 确定本工程有这个类，才可以实例化
Student stu=new Student();
// 本工程没有这个类，也可以编译通过，但是会在运行期报错
// Object newInstance = Class.forName("com.ycx.reflect.Student").newInstance();
Class clz2 = stu.getClass();
3、Class.forName()
//3、Class.forName("类的全路径名");
Class clz3 = Class.forName("com.ycx.reflect.Student");三： 反射实例化：
大多数时候我们不能直接拿到一个类的实例，就能通过反射来拿到对象了。
* 反射实例化
* 1、无参数 共有的构造方法
* 2、有参数 共有的构造方法
* 3、有多个参数 共有的构造方法
* 4、私有的构造方法
方法讲解：
1、.newInstance()：获取到该类的一个对象。
Student stu1 = stuClz1.newInstance();
2、getConstructor（）； 调用类中的方法。其中括号里面是填的类型Constructor<Student> c = stuClz1.getConstructor(String.class);
3、.getDeclaredConstructor（）；调用类中的方法。
其中括号里面是填的类型
Constructor<Student> c2 = stuClz1.getConstructor(String.class,String.class);
4、getConstructor（）和getDeclaredConstructor（）的方法比较。
getConstructor（）：主要用于私有方法，
getDeclaredConstructor（）：主要用于公有方法，使用该方法时要设置访问权限。
c3.setAccessible(true);
看一个完整案例代码：
package com.ycx.reflect;
import java.lang.reflect.Constructor;
/**
* 反射实例化
* 1、无参数 共有的构造方法
* 2、有参数 共有的构造方法
* 3、有多个参数 共有的构造方法
* 4、私有的构造方法
* @author 杨总
*
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
Student stu1=new Student();
Student stu2=new Student("s001");
Student stu3 = new Student("s001", "杨总");
/*********以下均为反射的方式实例化对象**********/
//获取类类
Class<? extends Student> clz1 = stu1.getClass();
//默认调用无参的 共有的 构造函数
// 1、无参数 共有的构造方法
Student stu4 = clz1.newInstance();
// 2、有参数 共有的构造方法
// 拿到构造器对象 三个.代表可以传1个2个..n个参数--->拿到一个参数为String的构造器对象
Constructor<? extends Student> c1 = clz1.getConstructor(String.class);
Student stu5=c1.newInstance("s001");
// 3、有多个参数 共有的构造方法 拿到有两个参数的构造器对象
Constructor<? extends Student> c2 = clz1.getConstructor(String.class,String.class);
Student stu6 = c2.newInstance("s001","颜大老婆");
// 4、私有的构造方法
// getConstructor只能获取共有的构造方法 要获取私有的构造器:getDeclaredConstructor
Constructor<? extends Student> c3 = clz1.getDeclaredConstructor(Integer.class);
// 打开访问权限
c3.setAccessible(true);
Student stu7 = c3.newInstance(18);
}
}
运行效果如下：
四：反射动态方法的调用：
* 1、调用无参数的 共有方法
1、先拿到类类
Class<Student> clz=Student .class;
// name:方法名 parameterTypes:方法对应的参数
Method m1 = clz.getMethod("hello");
// 调用对应的方法
// 第一个参数，那个类实例，第二个参数：方法调用时的实参
// m1.invoke方法调用的返回值就是方法对象本身的返回值hello方法的返回值
Object invoke = m1.invoke(clz.newInstance());
System.out.println(invoke); 
* 2、调用1个有参数的 共有方法
// 调用1个有参数的 共有方法
Method m2 = clz.getMethod("hello", String.class);
Object invoke2 = m2.invoke(clz.newInstance(), "杨总");
System.out.println(invoke2); 
* 3、调用私有的方法
// 调用私有的方法
Method m3 = clz.getDeclaredMethod("add", Integer.class,Integer.class);
m3.setAccessible(true);
Object invoke3 = m3.invoke(clz.newInstance(), 5,5);
System.out.println(invoke3);
五：反射读取属性：
package com.ycx.reflect;
import java.lang.reflect.Field;
/**
* 反射读写属性
* @author 杨总
*
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu= new Student("s003","杨总");
stu.age=20;
// 需求：要拿到这个学生所有的属性及属性值
System.out.println("age:"+stu.age);
System.out.println("sname:"+stu.getSname());
System.out.println("sid:"+stu.getSid());
/**
* 上述代码存在问题
* 1、你事先得知道这个类有哪些属性
* 2、假设student有三十个属性呢？
*/
// 一切反射从类类开始
Class<? extends Student> clz= stu.getClass();
// 当前类的所有属性对象
Field[] fields = clz.getDeclaredFields();
System.out.println(fields.length);
// for循环中的f代表每一个属性对象
for (Field f : fields) {
//打开访问权限
f.setAccessible(true);
// 通过属性对象拿到属性名称
System.out.println(f.getName());
//拿到当前的属性对象的属性值
System.out.println(f.get(stu));
}
}
}
课外拓展：
如何判断类或变量、方法的修饰符，可以使用Java反射机制中，
Field的 getModifiers() 方法
（访问修饰符）
返回int类型值表示该字段的修饰符，
即这个方法就是返回一个int型的返回值，代表类、成员变量、方法的修饰符。
其中，该修饰符是java.lang.reflect.Modifier的静态属性。（简单了解即可）
今天的分享就到这里了。如有缺漏，希望大神多多指点。