java反射

一、获取Class对象的三种方式
1.1 Object ——> getClass();
1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
1.3 通过Class类的静态方法：forName（String  className）(常用)
public class Fanshe {
public static void main(String[] args) {
        
//第一种获取Class的方式
   Student std1 = new Student();
        Class stuClass = std1.getClass();
        System.out.println(stuClass.getName());
        //第二种获取Class的方式
        Class stuClass2 = Student.class;
        System.out.println(stuClass == stuClass2);
        //第三种获取CLass的方式
        try {
Class stuClass3 =  Class.forName("com.imnu.fs.Student");
System.out.println(stuClass2 == stuClass3);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
注意：在运行期间，一个类，只有一个Class对象产生。
      三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。
      一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。


二、通过反射获取构造方法并使用：
package com.imnu.fs;


public class Student {
private String name;
private int age;

public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


//---------------构造方法-------------------
//（默认的构造方法）
Student(String str){
System.out.println("(默认)的构造方法 s = " + str);
}

//无参构造方法
public Student(){
System.out.println("调用了公有、无参构造方法执行了。。。");
}

//有一个参数的构造方法
public Student(char name){
System.out.println("姓名：" + name);
}

//有多个参数的构造方法
public Student(String name ,int age){
System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
}

//受保护的构造方法
protected Student(boolean n){
System.out.println("受保护的构造方法 n = " + n);
}

//私有构造方法
private Student(int age){
System.out.println("私有的构造方法   年龄："+ age);
}


@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}

 
}




package com.imnu.fs;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


public class Constructors {


public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("com.imnu.fs.Student");


// 2.获取所有公有构造方法
System.out.println("**********************所有公有构造方法*********************************");
Constructor[] conArray = clazz.getConstructors();
for (Constructor c : conArray) {
System.out.println(c);
}


System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
conArray = clazz.getDeclaredConstructors();
for (Constructor c : conArray) {
System.out.println(c);
}


System.out.println("*****************获取公有、无参的构造方法*******************************");
Constructor con = clazz.getConstructor(null);
// 1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
// 2>、返回的是描述这个无参构造函数的类对象。


System.out.println("con = " + con);
// 调用构造方法
        Object obj = con.newInstance();
System.out.println("obj = " + obj);
Student stu = (Student)obj;
stu.setAge(12);
stu.setName("wangqing");
System.out.println("调用方法" + stu.toString());



System.out.println("******************获取私有构造方法，并调用*******************************");
con = clazz.getDeclaredConstructor(char.class);
System.out.println(con);
// 调用构造方法
con.setAccessible(true);// 暴力访问(忽略掉访问修饰符)
obj = con.newInstance('男');
}


}
调用方法：
  1.获取构造方法：
  1).批量的方法：
            public Constructor[] getConstructors()：所有"公有的"构造方法
            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
     
  2).获取单个的方法，并调用：
            public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
            public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；


  调用构造方法：
           Constructor-->newInstance(Object... initargs)


  2、newInstance是 Constructor类的方法（管理构造函数的类）
           api的解释为：
           newInstance(Object... initargs)
           使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
           它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用
三、获取成员变量并调用
public class Student {


public Student() {


}
public String name;
protected int age;
char sex;
private String phoneNum;


@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", phoneNum=" + phoneNum + "]";


}
}


public class Constructors {


public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("com.imnu.fs.Student");
System.out.println("*************获取公有字段**并调用***********************************");
Field f = clazz.getField("name");
System.out.println(f);
//获取一个对象
Object obj1 = clazz.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj1, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
//验证
Student stu = (Student)obj1;
System.out.println("验证姓名：" + stu.name);


}


}
由此可见
调用字段时：需要传递两个参数：
Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
第一个参数：要传入设置的对象，第二个参数：要传入实参
四获取成员方法并且调用


public class Student {
//**************成员方法***************//
public void show1(String s){
System.out.println("调用了：公有的，String参数的show1(): s = " + s);
}
protected void show2(){
System.out.println("调用了：受保护的，无参的show2()");
}
void show3(){
System.out.println("调用了：默认的，无参的show3()");
}
private String show4(int age){
System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
return "abcd";
}
}


public class MethodClass {
 
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("fanshe.method.Student");
//2.获取所有公有方法
System.out.println("***************获取所有的”公有“方法*******************");
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取所有的方法，包括私有的*******************");
methodArray = stuClass.getDeclaredMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取公有的show1()方法*******************");
Method m = stuClass.getMethod("show1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "刘德华");

System.out.println("***************获取私有的show4()方法******************");
m = stuClass.getDeclaredMethod("show4", int.class);
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);


}
}
由此可见：
m = stuClass.getDeclaredMethod("show4", int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);//


五反射main方法
public class Student {
 
public static void main(String[] args) {
System.out.println("main方法执行了。。。");
}




public class Main {

public static void main(String[] args) {
try {
//1、获取Student对象的字节码
Class clazz = Class.forName("fanshe.main.Student");

//2、获取main方法
Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
//3、调用main方法
// methodMain.invoke(null, new String[]{"a","b","c"});
//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
//这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二

} catch (Exception e) {
e.printStackTrace();
}


}
}
六 反射方法的其他使用--通过反射运行配置文件内容
public class Student {
public void show(){
System.out.println("is show()");
}
}


配置文件pro.txt
className = cn.fanshe.Student
methodName = show


public class Demo {
public static void main(String[] args) throws Exception {
//通过反射获取Class对象
Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
//2获取show()方法
Method m = stuClass.getMethod(getValue("methodName"));//show
//3.调用show()方法
m.invoke(stuClass.getConstructor().newInstance());

}

//此方法接收一个key，在配置文件中获取相应的value
public static String getValue(String key) throws IOException{
Properties pro = new Properties();//获取配置文件的对象
FileReader in = new FileReader("pro.txt");//获取输入流
pro.load(in);//将流加载到配置文件对象中
in.close();
return pro.getProperty(key);//返回根据key获取的value值
}
}
需求：
当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动
七 通过反射越过泛型检查
public class Demo {
public static void main(String[] args) throws Exception{
ArrayList<String> strList = new ArrayList<>();
strList.add("aaa");
strList.add("bbb");

// strList.add(100);
//获取ArrayList的Class对象，反向的调用add()方法，添加数据
Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
//获取add()方法
Method m = listClass.getMethod("add", Object.class);
//调用add()方法
m.invoke(strList, 100);

//遍历集合
for(Object obj : strList){
System.out.println(obj);
}
}
}