其他分享
首页 > 其他分享> > 反射机制

反射机制

作者:互联网

反射机制(Reflection)

1.静态与动态语言

静态语言:运行时结构不可变的语言,如Java、C、C++。

动态语言:运行时可以改变其结构的语言,如C#、JavaScript、PHP、Python等。

Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用

反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

2.什么是反射

​ 在java中,一个类加载完之后,在堆内存的方法区中就产生了一个Class类型的对象(并且一个类只有一个Class对象),这个对象包含了类的完整的结构信息,就像是一面镜子,透过这个镜子看到类的结构的过程,称之为反射。

​ Reflflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflflection API取

得任何类的内部信息,并能直接操作任意对象的内部属性及方法。

获取一个类的Class对象:

Class c = Class.forName("java.lang.String")

3.获取Class对象的几种方式


//获取class对象的方式
public class DemoTest2 {

    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);

        //方式一:通过实例化对象的getClass()方法
        Class c1 = person.getClass();

        //方法二:通过Class.forName()+文件路径 方法
        Class c2 = Class.forName("reflect.Student");

        //方法三:直接通过 类.class方法
        Class c3 = Student.class;

        //Person、Student、Teacher虽然有继承关系,class类不受继承关系影响,一个类对应一个class

        //方法四:基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        Class c5 =  Double.TYPE;

        //方法五:通过子类的class获取父类的class
        Class c6 = c1.getSuperclass();


        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);

    }

}




class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student() {
        this.name = "学生";
    }
}

class Teacher extends Person{
    public Teacher() {
        this.name = "老师";
    }
}

4.java内存分析

类的加载过程:

加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象

链接:

初始化:

/**
 * 内存分析
 */
public class DemoTest3 {

    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }


}


class A{

    static {
        System.out.println("A类的静态代码块");
        m=300;

    }

    public static int m=100;

    public A() {
        System.out.println("A类的无参构造器");
    }
}

结果:
    A类的静态代码块
    A类的无参构造器
    100

​ 上面代码执行过程分析,首先,在方法区中有DemoTest3类和A类的数据(包括静态变量、方法,常量池等),在执行类加载操作时,在堆中产生两个对象的

Class对象,在链接阶段m被初始化为0,随后在执行main方法时进行初始化操作,执行clinit方法,依次执行输出"A类的静态代码块",赋值m=300,m=100,输出

"A类的无参构造器"。

5.什么时候会发生类初始化?

类的主动引用一定会发生类的初始化:

类的被动调用不会发生类的初始化:

/**
 * 类的主动引用和被动引用
 */
public class DemoTest4 {

    static {
        System.out.println("main类静态代码块加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //类的主动引用(一定会发生类的初始化)

        //new对象时会发生主动引用
        Son son = new Son();
        //结果:main类静态代码块加载
        //父类的静态代码块被加载
        //子类的静态代码块被加载
        //父类被加载
        //子类被加载
        //在进行new操作时,首先Main方法所在类的静态代码块在链接阶段先执行,其次父类、子类的静态代码块,在类初始化时,先初始化父类,再初始化子类

        //调用反射时也会发生主动引用
        Class son = Class.forName("reflect.Son");
        //结果:main类静态代码块加载
        //父类的静态代码块被加载
        //子类的静态代码块被加载
        //通过反射的方式,获取Son类的Class对象,此处说会主动引用,但是结果输出的都是链接阶段的静态代码块中的内容,并没有构造器的输出语句
        
        //类的被动引用(不会发生类的初始化)
        //子类访问父类的静态变量,子类不会被加载,静态代码块也不会执行
        System.out.println(Son.m);
        //结果:main类静态代码块加载
        //父类的静态代码块被加载
        //10
        
       //访问类中的静态常量时,不会初始化类
       System.out.println(Son.n);
       //结果:main类静态代码块加载
        //10

    }
}




class Son extends Father{
    static {
        System.out.println("子类的静态代码块被加载");
    }

    public static final int n=10;

    public Son() {
        System.out.println("子类被加载");
    }
}


class Father{

    static {
        System.out.println("父类的静态代码块被加载");
    }

    public  static int m=10;

    public Father() {
        System.out.println("父类被加载");
    }
}

6.通过反射的Class对象获取类结构

public class DemoTest2 {

    public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException {
        Class c1 = Class.forName("com.lzl.reflection.User");

        //获取类名+包名 (如果通过对象实例获取的Class对象)
         System.out.println(c1.getName());
        //只获取类名
         System.out.println(c1.getSimpleName());
        //获取类中的公开属性
        Field[] fields = c1.getFields();
        for (int i = 0; i < fields.length; i++) {
            System.out.println(fields[i]);
        }
         //获取类中的所有属性
        Field[] declaredFields = c1.getDeclaredFields();
        for (int i = 0; i < declaredFields.length; i++) {
           System.out.println(declaredFields[i]);
        }
        //获取类中指定的属性(无法获取私有的属性)
        Field address = c1.getField("address");
        System.out.println(address);
        //获取类中指定的属性(私有、公开的属性都可以)
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获取类中的方法(包括父类的不包括私有的)
        Method[] methods = c1.getMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println(methods[i]);
        }
        //获取类中的方法(包括私有的,但是不包括父类的)
        Method[] declaredMethods = c1.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
        //System.out.println(declaredMethods[i]);
        }
        //也可以通过指定方法名称+参数类型,获取某一个方法,方式基本同上

        //获取类中的构造器(同样此方法不包含私有的构造器,也可以通过指定参数类型获取指定的构造器)
        Constructor[] constructors = c1.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
           System.out.println(constructors[i]);
        }
  }

}



public class User {
    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;

    public String address;

    public User() {
    }

   private User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

   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;
    }

   @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7. 反射的方式去实例化对象

public class DemoTest3 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

     Class c1 = Class.forName("com.lzl.reflection.User");

    //此方法默认调用类的无参构造器去实例化对象
    User user= (User) c1.newInstance();
    //System.out.println(user);

    //先获取构造器,后实例化对象(指定获取有参构造器)
    Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, String.class);
    User user2= (User) constructor.newInstance("lzl",12,"hahah");
    //System.out.println(user2);

    //通过反射去操作类中的方法
    User user3 = (User) c1.newInstance();
    Method setName = c1.getDeclaredMethod("setName", String.class);
    //通过invoke方法和反射获取的某个方法去设置对象的值,格式invoke(实例对象,要赋的值)
    setName.invoke(user3,"lzl");
    // System.out.println(user3);

     //通过反射去操作类中的属性
     User user4 = (User) c1.newInstance();
     Field name = c1.getDeclaredField("name");
     //对于私有的属性而言,无法直接对其进行赋值,需要先关闭代码检查的,才能赋值成功;公开的属性,没有此限制
     name.setAccessible(true);
     name.set(user4,"1111");
     System.out.println(user4); 
    }

}

8.setAccessible

9 .获取方法的参数类型和返回值类型

package reflect;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

public class DemoTest06 {

    public void test01(Map<String,User> map, List<String> list){
    }

    public Map<String,Object> test02(){
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = DemoTest06.class.getMethod("test01", Map.class, List.class);

        //获取方法的参数泛型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        //遍历查看方法的参数泛型
        for (Type genericParameterType : genericParameterTypes) {
            //System.out.println(genericParameterType);
            //获取真实的参数类型
            //判断获取到的泛型是否为参数化类型,如果是,强转为参数化类型,输出查看
            if(genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    //System.out.println(actualTypeArgument);
                }
            }
        }

        //获取方法的返回值泛型
        method  = DemoTest06.class.getMethod("test02",null);
        Type genericReturnType = method.getGenericReturnType();
        System.out.println(genericReturnType);
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }

    }
}

10.通过反射的方式去获取类中的注解

package reflect;

import java.lang.annotation.*;
import java.lang.reflect.Field;

/**
 * 通过反射去获取类中的注解信息
 */
public class DemoTest07 {

    public static void main(String[] args) throws NoSuchFieldException {
        //获取student2中的注解
        //类注解 获得类的所有注解
        Annotation[] annotations = Student2.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取指定名称的注解
       // Student2.class.getAnnotation(TableStu.class);



        //参数注解
        Field[] fields = Student2.class.getDeclaredFields();
        for (Field field : fields) {
            Annotation[] annotations1 = field.getAnnotations();
            for (Annotation annotation : annotations1) {
                System.out.println(annotation);
            }
        }

        //获取参数的指定注解
        Field field = Student2.class.getDeclaredField("id");
        FieldStu annotation = field.getAnnotation(FieldStu.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());


    }


}

@TableStu("db_stu")
class Student2{
    @FieldStu(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldStu(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldStu(columnName = "db_name",type = "varchar",length = 10)
    private String name;

    public Student2() {
    }

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//类注解
//作用在类上
@Target(ElementType.TYPE)
//注解的生命周期 运行时
@Retention(RetentionPolicy.RUNTIME)
@interface TableStu{
    String value();
}


//参数注解
//作用在参数上
@Target(ElementType.FIELD)
//注解的生命周期 运行时
@Retention(RetentionPolicy.RUNTIME)
@interface FieldStu{
    String columnName();
    String type();
    int length();
}

标签:反射,name,System,class,println,机制,public,out
来源: https://www.cnblogs.com/lzlbk-321/p/16611653.html