Java之反射机制详解「建议收藏」

文章目录

一、反射机制

二、反射机制有什么用

三、获取Class文件的三种方式

1、Class.forName()

2、getClass()方法

3、java类型的.class属性

四、通过反射实例化对象

五、通过读属性文件实例化对象

六、资源绑定器

七、类加载器

1、什么是加载器

2、JDK中自带的类加载器

3、双亲委派机制

八、Field

1、获取Field

2、反编译Field

3、通过反射机制访问java对象属性（重点掌握）

九、Method

1、可变长度参数

2、反射Method

3、反编译Method

4、通过反射机制调用方法（重点掌握）

十、Constructor

十一、获取父类和父接口

一、反射机制

反射机制在java.lang.reflect.*包下
反射机制相关的重要的类有

java.lang.Class：代表字节码文件，代表一个类型，代表整个类。

java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。

java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（局部变量）

二、反射机制有什么用

通过java语言中的反射机制可以操作字节码文件。有点类似于黑客（可以读和修改字节码文件。）通过反射机制可以操作代码片段。（class文件）让程序更加灵活。

三、获取Class文件的三种方式

1、Class.forName()

public class ReflectTest01 { 

   

    public static void main(String[] args) { 

   



    /* Class.forName() 1、静态方法 2、方法的参数是一个字符串 3、字符串需要的是一个完整的类名 4、完整类名必须带有包名。java.lang包也不能省略*/



    try { 

   

        Class c1 = Class.forName("java.lang.String");//c1代表的是String.class文件，或者说c1代表String类型

        Class c2 = Class.forName("java.util.Date");//c2代表Date类型

        Class c3 = Class.forName("java.lang.Integer");//c3代表Integer类型

        Class c4 = Class.forName("java.lang.System");//c4代表System类型}

    } catch (ClassNotFoundException e) { 

   

        e.printStackTrace();

    }

    }

}

如果只希望一个类的静态代码块执行，其他代码一律不执行，可以使用：Class.forName("完整类名");
这个方法的执行会导致类加载，类加载时，静态代码块执行。

2、getClass()方法

java中任何一个对象都有一个方法：getClass()

public class ReflectTest01 { 

   

    public static void main(String[] args) { 

   



    /* Class.forName() 1、静态方法 2、方法的参数是一个字符串 3、字符串需要的是一个完整的类名 4、完整类名必须带有包名。java.lang包也不能省略*/



        Class c1 = null;

    try { 

   

         c1 = Class.forName("java.lang.String");//c1代表的是String.class文件，或者说c1代表String类型
	}catch (ClassNotFoundException e) { 

   

        e.printStackTrace();

    }



    String s = "abc";

    Class x = s.getClass();//x代表String.class字节码文件，x代表String类型

        System.out.println(c1 == x); //true(==判断的是对象的内存地址)

    }

}

3、java类型的.class属性

java语言中任何一种类型，包括基本数据类型，它都有.class属性

Class z = String.class; //z代表String类型

Class k = Date.class;//k代表Date类型

四、通过反射实例化对象

获取.class能干什么？

通过Class的newInstance()方法来实例化对象。
注意：newInstance()方法内部实际上调用了无参数的构造方法，必须保证无参数构造存在才可以。

使用反射机制的方式来创建对象：

public class User { 

   

    public User() { 

   

        System.out.println("无参数的构造方法");

    }

}

public class ReflectTest02 { 

   

    public static void main(String[] args) { 

   



        try { 

   

            //通过反射机制，获取Class，通过Class；来实例化对象

            Class c = Class.forName("User");//c代表User类型



            //newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建。

            //重点是:newInstance()调用的是无参构造，必须保证无参构造是存在的！！！！

            Object obj = c.newInstance();



            System.out.println(obj);

        } catch (ClassNotFoundException e) { 

   

            e.printStackTrace();

        } catch (InstantiationException e) { 

   

            e.printStackTrace();

        } catch (IllegalAccessException e) { 

   

            e.printStackTrace();

        }

    }

}

五、通过读属性文件实例化对象

验证反射机制的灵活性。java代码只写一遍，在不改变java源代码的基础之上，可以做到不同对象的实例化。非常之灵活（符合OCP开闭原则：对扩展开放，对修改关闭）

classinfo.properties文件：

className = User

import java.io.FileReader;

import java.util.Properties;



public class ReflectTest03 { 

   

    public static void main(String[] args) throws Exception{ 

   

        //通过IO流读取classinfo.properties文件

        FileReader reader = new FileReader("classinfo.properties");

        //创建属性类对象Map

        Properties pro = new Properties();

        //加载

        pro.load(reader);

        //关闭流

        reader.close();



        //通过key获取value

        String calssName = pro.getProperty("className");

        System.out.println(calssName);



        //通过反射机制实例化对象

        Class c = Class.forName(calssName);

        Object obj = c.newInstance();

        System.out.println(obj);

    }

}

六、资源绑定器

java.util包下提供了一个资源绑定器，便于获取配置文件中的内容。使用以下方法的时候，属性配置文件×××.properties必须放到类路径下

import java.util.ResourceBundle;



public class ThreadTest04 { 

   

    public static void main(String[] args) { 

   

        //资源绑定器，只能绑定×××.properties文件。并且这个文件必须在src/类路径下。文件扩展名必须是properties

        //并且在写路径的时候，路径的后面扩展名不能写

        ResourceBundle bundle = ResourceBundle.getBundle("classinfo3");



        String className = bundle.getString("className");

        System.out.println(className);



    }

}

七、类加载器

1、什么是加载器

专门负责加载类的命令/工具。ClassLoader

2、JDK中自带的类加载器

启动类加载器：rt.jar

扩展类加载器：ext/*.jar

应用类加载器：classpath

假如执行以下代码：

String s = "abc";

代码在开始执行以前，会将所需要类全部加载到JVM当中。

通过类加载器加载，看到以上代码类加载器会找string. class文件，找到就加载，那么是怎么进行加载的呢?

首先通过 “启动类加载器” 加载。
注意:启动类加载器专门加载: C: \Program Files\Java\jdk1.8.0_ 101\jre\lib\rt.jar
rt. jar中都是JDK最核心的类库。

如果通过 “启动类加载器”加载不到的时候,会通过 “扩展类加载器” 加载。
注意:扩展类加载器专门加载: C: \Program Files\Java\jdk1.8.0_ 101\jre\lib\ext\*.jar

如果 “扩展类加载器” 没有加载到，那么会通过 “应用类加载器” 加载。
注意：应用类加载器专门加载：classpath中的类。

3、双亲委派机制

java中为了保证类加载的安全，使用了双亲委派机制。优先从启动类加载器中加载，这个称为 “父”，”父”无法加载到，再从扩展类加载器中加载，这个称为**“母”。双亲委派。如果都加载不到，才会考虑从应用类加载器**中加载。直到加载到为止。

八、Field

1、获取Field

反射属性Field，Field翻译为字段，其实就是属性/成员。
4个Field，分别采用了不同的访问控制权限修饰符

public class Student { 

   

    //4个Field，分别采用了不同的访问控制权限修饰符

    public int no;

    private String name;

    protected int age;

    boolean sex;

}

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;



public class ReflectTest05 { 

   

    public static void main(String[] args) throws Exception{ 

   

        //获取整个类

        Class studentClass = Class.forName("Student");

        //获取类中所有的public修饰的Field

        Field[] fields = studentClass.getFields();

        System.out.println(fields.length);

        //取出这个Field的名

        Field f = fields[0];

        String fieldName = f.getName();

        System.out.println(fieldName);



        //获取所有的Field

        Field[] fields1 = studentClass.getDeclaredFields();

        System.out.println(fields1.length);



        for (Field field : fields1) { 

   

            //获取属性的修饰符

            int i = field.getModifiers();//返回的修饰符是一个数字，每个数字都是修饰符的代号

            System.out.println(i);

            //将代号转化为字符串

            String modifiersString = Modifier.toString(i);

            System.out.println(modifiersString);

            //获取属性的类型

            Class fieldType = field.getType();

            String fName = fieldType.getName();

            System.out.println(fName);

            //获取属性的名字

            System.out.println(field.getName());

        }

    }

}

2、反编译Field

通过反射机制，反编译一个类的属性Field

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;



public class ReflectTese06 { 

   

    public static void main(String[] args) throws Exception{ 

   

        //创建这个是为为了拼接字符串。

        StringBuilder s = new StringBuilder();



        Class studentClass = Class.forName("Student");



        s.append(Modifier.toString(studentClass.getModifiers())+ " class "+ studentClass.getSimpleName() + "Student{\n");



        Field[] fields = studentClass.getDeclaredFields();



        for (Field field : fields) { 

   

            s.append("\t");

            s.append(Modifier.toString(field.getModifiers()));

            s.append(" ");

            s.append(field.getType().getSimpleName());

            s.append(" ");

            s.append(field.getName());

            s.append(";\n");

        }

        s.append("}");

        System.out.println(s);



    }

}

运行结果：

3、通过反射机制访问java对象属性（重点掌握）

给属性赋值set
获取属性的值get

import java.lang.reflect.Field;



public class ReflectTest07 { 

   

    public static void main(String[] args) throws Exception { 

   

        //不使用反射机制怎样访问一个对象的属性

        Student s = new Student();



        //给属性赋值

        s.no = 1111;



        //读属性值

        System.out.println(s.no);



        //使用反射机制，访问一个对象的属性

        Class studentClass = Class.forName("Student");

        Object obj = studentClass.newInstance();//obj就是Student对象。（底层调用无参数构造方法）



        //获取no属性(根据属性的名称来获取Field)

        Field noField = studentClass.getDeclaredField("no");



        //给obj对象（student对象）的no属性赋值

        /*虽然使用了反射机制，但是三要素还是缺一不可： 要素1：obj对象。 要素2：no属性； 要素3:2222值。 注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。 */

        noField.set(obj,2222);//给obj对象的no属性赋值2222



        //读取属性的值

        //两个要素：获取obj对象的no属性的值。

        System.out.println(noField.get(obj));

    }

}

九、Method

1、可变长度参数

int... args这就是可变长度参数
语法是：类型... (注意：一定是3个点)

1、可变长度参数要求的参数个数是：0~N个。

2、可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有一个。

public class ArgsTest { 

   

    public static void main(String[] args) { 

   

        m();

        m(10);

        m(10,20);



    }

    public static void m(int... args){ 

   

        System.out.println("m方法执行了！");

    }

}

运行结果：

2、反射Method

public class User { 

   


public int id;
private String name;	
String address;
protected int sno;
public User() { 

   }

public User(int id, String name, String address, int sno) { 

   
	super();
	this.id = id;
	this.name = name;
	this.address = address;
	this.sno = sno;
}

public void study() { 

   
	System.out.println("study...");
}

public void eat(int a,String b) { 

   
	System.out.println("eat...");
}

}

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;



public class Test { 

   
public static void main(String[] args) throws Exception { 

   
	// 获取类

        Class usrClass = Class.forName("com.lzj.reflect.pojo.User");



        // 获取所有的Method（包括私有）

        Method[] methods = usrClass.getDeclaredMethods();

        

        // 遍历Method

        for(Method method : methods){ 

   

            // 获取修饰符列表

            System.out.println(Modifier.toString(method.getModifiers()));

            // 获取方法的返回值类型

            System.out.println(method.getReturnType().getSimpleName());

            // 获取方法名

            System.out.println(method.getName());

            // 方法的修饰符列表（一个方法的参数可能会有多个）

            Class[] parameterTypes = method.getParameterTypes();

            for(Class parameterType : parameterTypes){ 

   

                System.out.println(parameterType.getSimpleName());

            }

        }
}

}

3、反编译Method

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;



public class Test { 

   
public static void main(String[] args) throws Exception { 

   
	StringBuilder s = new StringBuilder();

        Class userClass = Class.forName("com.lzj.reflect.pojo.User");

        s.append(Modifier.toString(userClass.getModifiers()) + " class "+userClass.getSimpleName()+" {\n");



        Method[] methods = userClass.getDeclaredMethods();

        for(Method method : methods){ 

   

        	

            s.append("\t");

            s.append(Modifier.toString(method.getModifiers()));

            s.append(" ");

            s.append(method.getReturnType().getSimpleName());

            s.append(" ");

            s.append(method.getName());

            s.append("(");

            

            Class[] parameterTypes = method.getParameterTypes();

            for(Class parameterType : parameterTypes){ 

   

                s.append(parameterType.getSimpleName());

                s.append(",");

            }

            

            if(parameterTypes.length > 0) { 

   

            	s.deleteCharAt(s.length() - 1);

            }

            

            s.append("){}\n");

        }

        s.append("}");

        System.out.println(s);
}

}

4、通过反射机制调用方法（重点掌握）

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;



public class Test { 

   



    public static void main(String[] args) { 

   

        try { 

   

            Class clazz = Class.forName("com.lgz.Test");

            Method method = clazz.getMethod("run");

            method.invoke(clazz.newInstance());



            Method methodPrivate = clazz.getDeclaredMethod("eat");

            methodPrivate.setAccessible(true);//调private方法

            methodPrivate.invoke(clazz.newInstance());



            Method methodStatic = clazz.getMethod("work");

            methodStatic.invoke(null);



            Method method1 = clazz.getMethod("speak", int.class, String.class);

            method1.invoke(clazz.newInstance(), 22, "小明");

        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) { 

   

            e.printStackTrace();

        }



    }



    public static void work() { 

   

        System.out.println("work() 方法被调用...");

    }



    private void eat() { 

   

        System.out.println("eat() 方法被调用...");

    }



    public void run() { 

   

        System.out.println("run() 方法被调用...");

    }



    public void speak(int age, String name) { 

   

        System.out.println("speak() 方法被调用.... age = " + age + " name= " + name);

    }

}

十、Constructor

1）得到某个类所有的构造方法

Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
2）得到某一个构造方法

Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
实例

Constructor constructor = String.class.getConstructor(StringBuffer.class);

String str = (String) constructor.newInstance(new StringBuffer("abc"));

System.out.println(str.charAt(2));

打印结果：c

十一、获取父类和父接口

public class ReflectTest08 { 

   

    public static void main(String[] args) throws Exception{ 

   

        //String举例

        Class stringClass = Class.forName("java.lang.String");



        //获取String的父类

        Class superClass = stringClass.getSuperclass();

        System.out.println(superClass);



        //获取String类实现的所有接口（一个类可以实现多个接口）

        Class[] interfaces = stringClass.getInterfaces();

        for (Class anInterface : interfaces) { 

   

            System.out.println(anInterface);

        }

    }

}

Java之反射机制详解「建议收藏」

文章目录

一、反射机制

二、反射机制有什么用

三、获取Class文件的三种方式

1、Class.forName()

2、getClass()方法

3、java类型的.class属性

四、通过反射实例化对象

五、通过读属性文件实例化对象

六、资源绑定器

七、类加载器

1、什么是加载器

2、JDK中自带的类加载器

3、双亲委派机制

八、Field

1、获取Field

2、反编译Field

3、通过反射机制访问java对象属性（重点掌握）

九、Method

1、可变长度参数

2、反射Method

3、反编译Method

4、通过反射机制调用方法（重点掌握）

十、Constructor

十一、获取父类和父接口

相关推荐