java反射机制

1.通过例子了解Java反射机制

package java_reflect;

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

    static{
        System.out.println("我是static的静态代码块！！");
    }
    public Person(){}
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    private Person(String name){
        this.name=name;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public void eat(){
        System.out.println("人在吃饭！");
    }
    private void sleepPrivate(){
        System.out.println("我正在睡觉！！！！！");
    }
    
    public  boolean action(String name,int age){
        
        System.out.println("我是带有参数的方法，通过反射能执行！");
        return true;
    }
    
    private  void playGame(String name,int age){
        System.out.println("人在打游戏："+name+" "+age);
    }
    
}

 

 

package java_reflect;
/**
 * 获取一个类class文件对象的三种方式：
 * 1.类名字
 * 2.对象
 * 3.class类的静态方法获取
 * */
public class ReflectDemo {
    
    public static void main(String[] args) throws ClassNotFoundException {
        //1.对象获取
        Person p=new Person();
        Class c=p.getClass();
        System.out.println(c);
        
        //2.类名获取
        //每一个类型，包括基本和引用，都会赋予这个类型一个静态的属性，属性名字class
        Class c1= Person.class;
        System.out.println(c1);
        
        //person这个类的class文件只有一个，虚拟机只会给这个文件创建一个唯一的Class类
        //所以c1和p的内存地址都是相等的
        System.out.println(c1==c);//true
        System.out.println(c1.equals(c));//true
        
        //3.Class类的静态方法获取forname(字符串的类名)
        Class c3=Class.forName("java_reflect.Person");
        System.out.println(c3);
        
        //这三个方法拿到的对象都是唯一的一个对象
    }
}

 

 

package java_reflect;

import java.lang.reflect.Constructor;

/**
 * 通过反射获取class文件中的构造方法，运行构造方法
 * 运行构造方法，创建对象
 *         获取class文件对象
 *         从class文件对象中，获取需要的成员
 * 
 * Constructor 描述构造方法对象的类
 * */
public class ReflectDemo2 {
    
    public static void main(String[] args) throws Exception, NoSuchMethodException {
        Class c=Class.forName("java_reflect.Person");
        //使用Class文件对象，获取类中的构造方法，找到类class，获取构造器
        //getConstructors()获取class文件对象中的所有公共的构造方法
        System.out.println("获得共有的所有的构造方法:");
        Constructor[] cons= c.getConstructors();
        for(Constructor con:cons){
            System.out.println(con);
            /**
             * public java_reflect.Person()
                public java_reflect.Person(java.lang.String,int)
             * */
        System.out.println("获取指定的构造方法！");
        //空参数的构造方法
            System.out.println("空参数:");
            Constructor conss= c.getConstructor();
            System.out.println(conss);
            //运行空参数的构造方法，newInstence
            Object objPerson=conss.newInstance();
            System.out.println(objPerson);
            Object obj1=conss.newInstance();
            System.out.println(obj1);
        }
    }
}

 

package java_reflect;
/**
 *关于反射和new：知识点
 *1.ram和rom 2.对内存和栈内存的区别，以及数据结构的方式，以及存储的到底是什么
 *3.new 和反射是2中不同的设计方式:关键字；动态开辟一个对象和直接开辟多个对象
 * 
 * */
import java.lang.reflect.Constructor;

public class ReflectDemo3 {
    
    public static void main(String[] args) throws Exception {
        Class c=Class.forName("java_reflect.Person");
        //Class...parameterTypes基本数据类型的Class文件
        //1.获取带有参数的构造函数的参数列表
        Constructor con= c.getConstructor(String.class,int.class);
        System.out.println(con);
        //2.运行构造方法:initargs（实际参数）
        Person p=(Person) con.newInstance("haha",35);
        System.out.println(p);
    }
}

 

 

package java_reflect;
/**
 * 反射获取构造方法并运行，有快捷的方式
 * 有前提：
 *         被反射的类，必须是有空参数构造方法
 *         构造方法的权限必须是public
 * */
public class ReflectDemo4 {
    
    public static void main(String[] args) throws Exception{
        Class c=Class.forName("java_reflect.Person");
        //Class类中定义了一个方法，newInstance()
        
        //注意这个Class类中的方法newInstance是不能传递参数的
        //这样也使得构造方法必须是有一个空参数的构造方法
        //所以我们在写类的时候如果用到反射，最好也是写上空参数构造器
        Object obj=c.newInstance();
        System.out.println(obj);
    }
}

 

 

package java_reflect;

import java.lang.reflect.Constructor;

/**
 * 反射获取私有的构造方法运行
 *     不推荐，破坏了程序的封装性
 * 
 * 我们可以使用暴力反射，强行打破Java中的类在运行时的权限
 * */
public class ReflectDemo6 {
    
    public static void main(String[] args) throws Exception {
        Class c=Class.forName("java_reflect.Person");
        //获得私有的构造器getDeclaredConstructors() 
        Constructor [] cons=c.getDeclaredConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }
        System.out.println("私有的指定的一个私有构造器！");
        Constructor conPrivate=c.getDeclaredConstructor(String.class);
        System.out.println(conPrivate);
//        Person p2=(Person)conPrivate.newInstance("李泽博！");
        //错误，main中无法访问私有的构造器
        
        //1.使用暴力反射
        /**
         * AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。
         * 对于公共成员、默认（打包）访问成员、受保护成员和私有成员，
         * 在分别使用 Field、Method 或 Constructor 
         * 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，
         * 会执行访问检查。
         * */
        Constructor con=c.getDeclaredConstructor(String.class);
        con.setAccessible(true);
        //运行私有的构造器！！ 
        con.newInstance("李泽博！！！！！！！！！");
    }
}

 

 

package java_reflect;

import java.lang.reflect.Field;

public class ReflectDemo7 {

        public static void main(String[] args) throws Exception{
            Class  c=Class.forName("java_reflect.Person");
            Object obj=c.newInstance();
            //获取成员变量的Clas变量的方法getField class文件中所有公共的成员变量
            //返回值是Field[] Fiel类描述成员变量对象的类
            
            //拿的是公有的成员变量
            System.out.println("拿的是私有的成员变量");
            Field[] fields= c.getFields();
            for(Field field:fields){
                System.out.println(field);
            }
            //私有的，公有的一起，也即是声明了的变量
            System.out.println("私有的 :");
            Field [] fiels1=c.getDeclaredFields();
            for(Field fiels:fiels1){
                System.out.println(fiels);
            }
            //获取指定的一个成员变量
            System.out.println("获取指定的一个成员变量");
            Field fieldss=c.getField("name");
            System.out.println(fieldss);
            
            System.out.println("改掉变量值为'王五'");
            fieldss.set(obj, "王五！！");
            
            System.out.println(obj);
            //这里如果我们不是用obj,上面创建的对象，那么使用c.newInstance()会使得
            //你创建了2个对象，使得结果是null，0
        }
}

 

 

package java_reflect;

import java.lang.reflect.Method;

public class ReflectDemo8 {

    public static void main(String[] args) throws Exception {
        Class c=Class.forName("java_reflect.Person");
        Object obj=c.newInstance();
        //获取到成员方法
        //Method []getMethods()获取的是Class文件的所有公共的成员方法，包括继承的
        //Method是描述成员方法的对象类
        System.out.println("成员方法：");
        Method [] methods= c.getMethods();
        for(Method method:methods){
            System.out.println(method);
        }
        System.out.println("利用反射使用method:");
        Method method= c.getMethod("eat");
        System.out.println(method);
        method.invoke(obj);
    }
}

 

package java_reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo9 {
    
    public static void main(String[] args) throws Exception {
        Class c=Class.forName("java_reflect.Person");
        Object obj=c.newInstance();
        
        Method method= c.getMethod("action", String.class,int.class);
        boolean  bool=(Boolean) method.invoke(obj,"李泽博",23);
        System.out.println(bool);
        //通过反射获取私有的带参数的方法
        System.out.println("通过反射获取私有的带参数的方法");
        Object obj1=c.newInstance();
        Method method1=c.getDeclaredMethod("playGame", String.class,int.class);
        //在使用反射式，取消Java中权限
        method1.setAccessible(true);
        method1.invoke((Person)obj1, "李泽博sdf",23);
        
    }
}

 

反射进行的泛型擦除：

package java_reflect;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * 定义集合类，泛型String
 * 要求向集合中添加Integer类型
 * 
 * 反射方式，获取 出集合ArrayList类的class文件对象
 * 通过class文件都对象，通过调用add()方法
 * 
 *为什么可以使用这种方式:因为在编译器中是没有泛型这种类型的，所以在.class文件对象中可以使用这种方式
 * */
public class ReflectDemo10 {
    
    public static void main(String[] args) throws Exception{
        ArrayList<String> array=new ArrayList<String>();
        array.add("例子莪");
        //反射方式进行泛型擦除，在ArrayList源码中其实是一个对象数组，所以可以进行储存各种类型，
        //但是通过泛型又有了约束
        Class c=Class.forName("java.util.ArrayList");
        Method method= c.getMethod("add",Object.class);
        System.out.println(method);
        System.out.println("使用反射技术~运行方法");
        
        //Object obj=c.newInstance();
        method.invoke(array, 1500);
        method.invoke(array, 200);
        System.out.println(array);
    }
}

 

 

使用反射可以让代码变得很灵活，比如读取配置文件，只需要修改配置文件的键值对就可以让程序运行不同的类和方法

package java_reflect_two;

public class Person {
        
    public void eat(){
        System.out.println("人在吃饭~");
    }
}

package java_reflect_two;

public class Student {
    
    public void study(){
        System.out.println("学生在学习！");
    }
}

package java_reflect_two;

public class Worker {
    
    public void job(){
        System.out.println("上班族在工作！");
    }
}

#className=java_reflect_two.Person
#methodName=eat

#className=java_reflect_two.Student
#methodName=study

className=java_reflect_two.Worker
methodName=job

package java_reflect_two;

import java.io.FileReader;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 调用Person方法，调用Student,调用Worker中的方法，也就是说
 * 运行哪个类是不确定的，类不清楚，方法也不清楚。
 * 
 * 通过配置文件实现此功能，以键值对的形式，写在文本中
 *     运行那个类，读取配置文集那即可
 *     实现步骤：
 *             1.准备配置文件，键值对
 *             2.IO流读取配置文件 Reader
 *             3.文件中的价值对存储到集合中：Properties
 *             4.直接用反射获取指定类的，class文件的对象
 *             5.获取方法，执行方法
 */
public class Test {
    
    public static void main(String args[]) throws Exception{
    
        //IO读取配置文件
        FileReader r=new FileReader("config.properties");
        //创建集合对象
        Properties pro=new Properties();
        pro.load(r);
        r.close();
        //通过键获取值
        
        String className=pro.getProperty("className");
        String methodName=pro.getProperty("methodName");
        //测试：System.out.println(className+": "+methodName);
        
        Class c=Class.forName(className);
        Object obj=c.newInstance();
        Method method=c.getMethod(methodName);
        method.invoke(obj);
    }
}