反射之中包含了一个“反”的概念，所以要想解释反射就必须先从“正”开始解释，一般而言，当用户使用一个类的时候，应该先知道这个类，而后通过这个类产生实例化对象，但是“反”指的是通过对象找到类
程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。
反射的核心是JVM在 运行时 才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁
Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method
定义如下一个类：
public class RefModel {
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
测试：
/**
* 使用了一个getClass()方法，而后就可以得到对象所在的“包.类”名称，这就属于“反”了
* getClass()就作为发起一切反射操作的开端
*/
public class TestRefModel {
public static void main(String[] args){
RefModel ref = new RefModel();//正着来
String className = ref.getClass().getName();//反着来
System.out.println("className:"+className);//className:com.tutorial.annotation.RefModel
}
}
RefModel的父类是Object类，getClass()方法就是Object类之中所定义的方法。
取得Class对象：public final Class<?> getClass()，反射之中的所有泛型都定义为?，返回值都是Object。 而这个getClass()方法返回的对象是Class类的对象，所以这个Class就是所有反射操作的源头。但是在讲解其真正使用之前还有一个需要先解释的问题，既然Class是所有反射操作的源头，那么这个类肯定是最为重要的，而如果要想取得这个类的实例化对象，Java中定义了三种方式：
- 使用“类.class”取得
Class cls = RefModel.class;//取得Class对象
- public static Class<?> forName(String className) throws ClassNotFoundException；
Class cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象
- 通过Object类的getClass()方法取得，基本不用
Class cla = ref.getClass();//取得Class对象
反射的应用：
- 实例化对象
对于对象的实例化操作之前一直依靠构造方法和关键字new完成,现在可以利用反射完成
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
Class<?> cla = Class.forName("com.tutorial.annotation.RefModel");
RefModel ref = (RefModel) cla.newInstance();//等价于new RefModel();
System.out.println(ref);
}
- 利用反射实现工厂模式
1.接口
public interface Fruit {
public void eat();
}
2.实现类
public class Apple implements Fruit{
@Override
public void eat() {
System.out.println("吃苹果");
}
}
3.工厂类
public class FruitFactory {
public static Fruit getInstance(String name){
Fruit fruit = null;
try {
fruit = (Fruit) Class.forName(name).newInstance();//反射实例化--此处是重点
} catch (Exception e) {
e.printStackTrace();
}
return fruit;
}
}
4.测试类
public class TestFactory {
public static void main(String[] args) {
Fruit fruit = FruitFactory.getInstance("com.tutorial.annotation.Apple");
fruit.eat();//吃苹果
}
}
- 调用构造方法
在RefModel中添加2个构造方法
public RefModel() {
super();
}
public RefModel(Integer id, String name) {
super();
this.id = id;
this.name = name;
}
获取构造方法
Class cla = Class.forName("com.tutorial.annotation.RefModel");
/**
* 1.获取所有的构造方法
* public com.tutorial.annotation.RefModel()
* public com.tutorial.annotation.RefModel(java.lang.Integer,java.lang.String)
*/
Constructor[] constructors = cla.getConstructors();
for(Constructor constructor:constructors){
System.out.println(constructor);
}
//实例化对象
Object obj1 = cla.newInstance();
System.out.println(obj1);
/**
* 2.获取指定的构造方法
*/
Constructor<?> constructor = cla.getConstructor(Integer.class,String.class);
Object obj2 = constructor.newInstance(1,"Jimmy");
RefModel model = (RefModel)obj2;
System.out.println(model.getName());//Jimmy
注意：如果实现了有参数的构造方法，却没有无参构造方法，Object obj1 = cla.newInstance()会报如下错误
Exception in thread "main" java.lang.InstantiationException: com.tutorial.annotation.RefModel
at java.lang.Class.newInstance(Class.java:364)
at com.tutorial.annotation.TestRefModel.main(TestRefModel.java:38)
- 调用普通方法-Method
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
Class<?> cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象
//1.返回所有公用（public）方法，包括其继承类的公用方法
Method[] methodAlls = cla.getMethods();
for(int x= 0; x< methodAlls.length; x++) {
System.out.println(methodAlls[x]);
}
//返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法
Method[] methodDecs = cla.getDeclaredMethods();
for(Method method:methodDecs){
System.out.println(method);
}
//2.获取指定的方法
//------------方法的调用-------------
Object obj = cla.newInstance();//实例化对象
String attribute = "name";//要调用类之中的属性
Method setMet = cla.getMethod("set"+initcap(attribute), String.class);
Method getMet = cla.getMethod("get"+initcap(attribute));
//调用
setMet.invoke(obj, "Jimmy");//相当于RefModel对象.setName("Jimmy");
System.out.println(getMet.invoke(obj));//相当于RefModel对象.getName("Jimmy");
}
public static String initcap(String str) {
return str.substring(0,1).toUpperCase().concat(str.substring(1)) ;
}
- 调用成员（属性）-Field
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
Class<?> cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象
//1.获取所有的属性
Field[] fields = cla.getDeclaredFields();
for(Field field:fields){
System.out.println(field);
}
//2.获取指定的属性
Object obj = cla.newInstance();//对象实例化之后才会为属性分配空间
Field nameField = cla.getDeclaredField("name");//获取name属性
nameField.setAccessible(true);//
nameField.set(obj, "Lucy");//RefModel对象.name="Lucy"
System.out.println(nameField.get(obj));
nameField.setAccessible(false);
}
用setAccessible方法设置为true,若override的值为true，表示忽略权限规则，调用方法时无需检查权限（也就是说可以调用任意的private方法，违反了封装
