反射机制是什么?是通过字节码文件找到其中的一个类,然后也可以找到类中的相关属性等。 我们正常一般的思维是编写java代码,然后代码会被编译为字节码文件。而我们的方法都是 自己在代码中写的,现在这个机制可以通过字节码找到代码中的属性。这就是反射机制的特 点。
这个方法是在Object类中的一个方法,去api查找详细的说明。
这个方法的返回类型是Object的运行时类,Object是所有类的父类。所以我们可以认为是返回一个类的对象。这个方法需要我们用实例化的对象去调用。这是基本的常识,所以我们任何情况下,想要用这个方法获取到字节码文件对象,就需要Object类的实例化对象或者继承自Object类的实例化对象。
似乎这种是一种更加简单的方式。
Class<Refelct_demo01> re_1 = Refelct_demo01.class;
根据api的说明举例就很容易明白了。
Class 提供了两个这样的重载方法。
注意返回是一个static修饰的类对象。 简单举例一下使用
Class<?> aClass = Class.forName("java_practice.Student");
三种获取Class 对象的区别(该段在语雀的公开文档引用)
getClass()
接在对象的后面。getClass() 是 Object 类中的方法,而 Object 类是所有 Java 类的父类。.class
接在任意一个 Class 类的后面,在编译期加载(静态加载)。Class.forName
是 Class 类中的一个静态方法,从指定的 classloader 中装载类,返回与给定字符串对应类或接口的 Class 对象,在运行期加载(动态加载)。关于静态加载和动态加载:
Class.forName() 和 ClassLoader 的 loadClass() 之间的区别:
我们要通过反射的方式进行实例化
现在想想,如果不用反射的话,我们怎么样实例化对象?通过new进行实例化。
Refelct_demo01 re = new Refelct_demo01();
但是反射是什么?我们先通过Class对象获得构造器。为什么要这样做?你可以理解为它是倒着来的。 我们正常的是有i了构造器,然后实例化。现在我们这样去做。
构造器的获取在Class类中一个给了两个,一个是指定构造器,一个是返回一个数组。我们来看。
注意这两个只能拿到public修饰的构造器,要想拿到全部。我们可以用
举例子 指定构造器
Class<?> aClass = Class.forName("java_practice.Student");
//基本数据类型也可以通过.class 得到对应的Class 类型
Constructor<?> con = aClass.getConstructor(int.class, String.class); //填入指定构造方法中的类型.class即可
System.out.println(con);//public java_practice.Student(int,java.lang.String)
//可获取到私有构造方法
Constructor<?> dd = aClass.getDeclaredConstructor(String.class);
System.out.println(dd);//private java_practice.Student(java.lang.String)
获取构造器数组对象
Class<?> aClass = Class.forName("java_practice.Student");
Constructor<?>[] cons = aClass.getConstructors();//拿到public类型的构造方法
for(Constructor con : cons)
{
System.out.println(con);
}
Constructor<?>[] dc = aClass.getDeclaredConstructors();//拿到所有的构造方法
for(Constructor dcc: dc)
{
System.out.println( dcc);
}
在获取到构造器之后呢,我们可以利用得到的构造器对象创建实例对象。
举个·例子,通过无参构造器来创建一个实例对象/类对象
同样可以获取到方法和成员变量
首先,我们还是可以先获取到Class对象,然后获取成员方法
api提供了两个获取一般方法的方法
同样一个是返回指定的方法对象,一个是返回一个数组
//获取单个方法公共的方法对象
Method m = aClass.getMethod("getName");
//获取到成员方法对象(包括了继承的方法)
Method[] methods = aClass.getMethods();
for(Method method:methods)
{
System.out.println(method);
}
但是这样获取的一般只是公共的方法,私有化的方法是获取不到的。Class 类也提供了获取所有的方法包括私有方法的方法。
Method speak__ = aClass.getDeclaredMethod("speak__");//static 修饰的方法
Method kk = aClass.getDeclaredMethod("kk");//kk是私有化方法
Method[] mm = aClass.getDeclaredMethods();
for(Method m : mm)
{
System.out.println(m );
}
与此相关的Class提供的方法
Field field = aClass.getField("say");//public类型的
Field[] fields = aClass.getFields();
for(Field f : fields)
{
System.out.println(f);
}
Field name = aClass.getDeclaredField("name");//name是私有的
Field[] ff = aClass.getDeclaredFields();
for(Field f : ff)
{
System.out.println(f);
}
我们已经了解到如何获取到Class对象,构造器,方法,局部变量。那么我们如果去调用一个方法或者如何去给一个类的成员变量赋值?
正常情况下,如果不是用到反射进行编程的话,我们可以用实例对象去调用一个方法。现在我们也实现实例方法对方法的人调用,只不过方式是不一样的。感受一下。
Class<?> aClass = Class.forName("java_practice.Student");//获取到Class 对象
Constructor<?> con = aClass.getConstructor();//获取获取构造器
Object o = con.newInstance();//获取实例化对象
Method m = aClass.getMethod("speak");//获取指定的方法对象
m.invoke(o);//调用实例化对象下的指定方法
注意对私有方法的调用的时候,还需要进行跳过访问检查,才可以调用到。具体参考。
Constructor<?> con = aClass.getConstructor();//获取获取构造器
Object o = con.newInstance();//获取实例化对象
Method kk = aClass.getDeclaredMethod("kk");//kk是私有化的
kk.setAccessible(true);//跳过访问检查
kk.invoke(o);
Field field = aClass.getField("say");
//获取无参构造方法创建对象
Constructor<?> con = aClass.getConstructor();
Object obj = con.newInstance();
field.set(obj,"hello");//给obj的成员变量say 赋值
Field field = aClass.getField("say");//获取成员变量对象
Constructor<?> con = aClass.getConstructor();//获取构造器
Object obj = con.newInstance();//获取类实例对象
field.set(obj,"hello");//给obj的成员变量say 赋值
Object o = field.get(obj);//获取obj对象下的成员say的对象
System.out.println(o);//获取到成员变量的值
私有化的成员变量的一样要越过访问检查
Field name = aClass.getDeclaredField("name");
Constructor<?> con_ = aClass.getConstructor();
Object o1 = con_.newInstance();
name.setAccessible(true);
name.set(o1,"jgdabc");
Object o = name.get(o1);
System.out.println(o);
这样的特点如何体现?
如果我定义一个集合,集合中的泛型是Integer的,我现在要给这个集合存放一个String类型的数据。 可以吗?用2反射的这个机制就可以实现。
package reflect_demo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
//实现ArrayList<Integer>集合,给利用反射的特点给集合当中添加字符串数据
public class ReflectDemo08 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
ArrayList<Integer> array = new ArrayList<Integer>();
array.add(1);
// 通过反射实现正常情况下,无法实现的操作
Class<? extends ArrayList> arr_cla = array.getClass();//还是获取到Class对象
Method m = arr_cla.getMethod("add", Object.class);//调用到add方法,可以知道这个是Object类型的方法
m.invoke(array, "hello"); //给array对象下的m里面的add方法传入值
//反射可以越过泛型检查的,获取到原始的参数所需要的参数类型
System.out.println(array);
}
}
有没有觉得很有逼数。
创建两个类
package reflect_demo;
public class Teacher666 {
public void teach()
{
System.out.println("love students");
}
}
package reflect_demo;
public class Student666 {
public void study()
{
System.out.println("study hard");
}
}
给一个简单的配置文件Class.txt
className = reflect_demo.Student666
methodName = study
然后测试类·
package reflect_demo;
//通过配置文件运行类中的方法
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
public class ReflectDemo09 {
public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
//加载数据
Properties prop = new Properties();
FileReader fileReader = new FileReader("E:\\java_doc\\src\\reflect_demo\\class.txt");
prop.load(fileReader);
fileReader.close();
String className = prop.getProperty("className");//相当于根据键获取到值。
String methodName = prop.getProperty("methodName");
//通过反射来使用
Class<?> c = Class.forName(className);
Constructor<?> con = c.getConstructor();
Object o = con.newInstance();
Method m = c.getMethod(methodName);
m.invoke(o);
}
}
这样做的好处是,在我想要在该类指定运行对象的时候,我不需要在该类中进行指定类,或者像之前一样进行new对象,我想要运行对象的哪个方法,就直接在配置文件中进行简单修改就可以了。这里就体现了反射的这方面的特点。简单演示一下。反射是非常重要的一个知识点。在Spring中就会有用到反射的知识点,所以感觉基础扎实点会比较好,如果不是理解的就去用的话,很容易陷入迷茫,并且效率很低。
反射的优点,我们上面的简单说明体现了一部分。缺点在于动态解析这些方面,以及安全等等。其实你从代码上可以看的出来,从字节码进行找到这个类,然后获取相关的属性等等,这样其实是比较麻烦的,浪费效率,另外代码是无法和常规编程一样进行优化。反射可以做到一些我们常规方式下五发进行的操作,所以会存在安全的隐患。这样的实现很明显会破坏掉类的封装性等等。
但是我们会用到它,在工厂模式下会有非常大的用处。感觉有趣。