Java基础第20天 反射

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_39109438/article/details/79980102

类加载,反射

类加载器

类的加载

当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初 始化三步来实现对这个类进行初始化。

  • 加载

    就是指将 class 文件读入内存,并为之创建一个 Class 对象。 任何类被使用时系统都会建立一个 Class 对象

  • 连接

    验证 是否有正确的内部结构,并和其他类协调一致
    准备 负责为类的静态成员分配内存,并设置默认初始化值
    解析 将类的二进制数据中的符号引用替换为直接引用

  • 初始化

    初始化阶段,虚拟机负责对类的变量进行初始化
    声明类变量是指定初始值
    使用静态初始化块为类变量指定初始值

    使用:正常使用
    卸载:GC(垃圾回收机制)把无用对象从内存中卸载。

Class 类的初始化时机

Java 虚拟机只有在程序首次主动使用一个类或接口的时候才会初始化它。只有 6 种活动被看 作是程序对类和接口的主动使用:

  • 创建类的实例
  • 调用类的静态方法
  • 访问类或接口的静态变量,或者为静态变量赋值
  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class 对象
  • 初始化某个类的子类
  • 直接使用 java.exe 命令来运行某个主类

类加载器

类加载器主要负责将.class 文件加载到内存中,并为之生成对应的 Class 对象。

类加载器的组成
  • Bootstrap ClassLoader 根类加载器 也被称为引导类加载器,负责 Java 核心类的加载 比如 System、String 等。在 JDK 中 JRE 的 lib 目录下 rt.jar 文件中

  • Extension ClassLoader 扩展类加载器 负责 JRE 的扩展目录中 jar 包的加载。 在 JDK 中 JRE 的 lib 目录下 ext 目录

  • Sysetm ClassLoader 系统类加载器 负责在 JVM 启动时加载来自 java 命令的 class 文件,以及 classpath 环境变量所指定 的 jar 包和类路径。

反射

JAVA 反射机制是在运行状态中:

  • 对于任意一个类,都能够知道这个类的所有属性和方法;
  • 对于任意一个对象,都能够调用它的任意一个方法和属性;

这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。

Class类

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是 Class 类中的 方法,所以先要获取到每一个字节码文件对应的 Class 类型的对象。

获取 Class 对象三种方式

  • 方式一:调用 Object 类的 getClass():任何类都会继承此方法

    Personp=newPerson();
    Classc=p.getClass()

  • 方式二:调用某个类的class属性来获取该类对呀的Class对象

    Classs=Student.class

  • 方式三:调用 Class 类的静态方法 forName(StringclazzName),参数的值是某个类的全限 定类名(必须添加完整包名)

    Classc3=Class.forName(“com.jf.weidong.Person”);

通过这个 Class 对象,可以获取 Student 类内部的成员属性、构造方法、成员方法的一些信 息,并能够调用它们

示例代码
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // TODO Auto-generated method stub

        /*
         * 获取 Class 对象三种方式
         */
        Student stu = new Student();
        Class c1 = stu.getClass();
        System.out.println(c1);

        Class c2 = Student.class;
        System.out.println(c2);

        Class c3 = Class.forName("classtry.Student");
        System.out.println(c3);
    }
}

反射操作构造方法

通过反射获取构造方法

在反射机制中,把类中的成员(构造方法、成员方法、成员变量)都封装成了对应的类进行 表示。其中,构造方法使用类 Constructor 表示。可通过 Class 类中提供的方法获取构造方 法:

- 获取单个

Constructor getConstructor(Class … parameterTypes):获取指定的”公有构 造方法”
Constructor getDeclaredConstructor(Class … parameterTypes):获取指定的 构造方法(包括私有的)

  • 批量获取构造方法

    Constructor[] getConstructors() :获取所有的”公有构造方法”
    Constructor[] getDeclaredConstructors() :获取全部(包括私有)的构造方法

  • 暴力访问:如果想要访问私有成员,需要设置暴力访问

Constructor 的 setAccessible(true):不进行权限检查

示例代码
public class Test02 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        //获取单个 
        // Constructor getConstructor(Class ... parameterTypes):获取指定的"公有构 造方法" 
        Class c = Class.forName("classtry.Student");
        Constructor con1 = c.getConstructor(String.class,int.class);
        System.out.println(con1);
        System.out.println("=============================");
        //   Constructor getDeclaredConstructor(Class ... parameterTypes):获取指定的 构造方法(包括私有的) 
        Constructor con2 = c.getDeclaredConstructor(String.class);
        System.out.println(con2);
        System.out.println("=============================");
        // 批量获取构造方法
        // Constructor[] getConstructors() :获取所有的"公有构造方法" 
        Constructor[] con3 = c.getConstructors();
        for (Constructor c1 : con3) {
            System.out.println(c1);
        }
        System.out.println("==============================");
        // Constructor[] getDeclaredConstructors() :获取全部(包括私有)的构造方法 
        Constructor[] con4 = c.getDeclaredConstructors();
        for (Constructor c2 : con4) {
            System.out.println(c2);
        }
    }

}

通过反射方式创建对象(共有构造)

  • 步骤如下
    1. 获取到 Class 对象
    2. 获取指定的构造方法
    3. 通过构造方法类 Constructor 中的方法,创建对象
      publicTnewInstance(Object…initargs)
示例代码
public class Test03 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub

        //publicTnewInstance(Object...initargs) 

        Class c = Class.forName("classtry.Student");
        Constructor con1 = c.getConstructor();
        Object obj1 = con1.newInstance();
        System.out.println(obj1);
        System.out.println("=========================");
        Constructor con2 = c.getConstructor(String.class,int.class);
        Object obj2 = con2.newInstance("张三",21);
        System.out.println(obj2);
        System.out.println("=========================");
        Constructor con3 = c.getDeclaredConstructor(String.class,int.class,String.class);
        Object obj3 = con3.newInstance("李四",22,"中国");
        System.out.println(obj3);
    }

}

通过反射方式创建对象(私有构造)

AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的 对象标记为在使用时取消默认 Java 语言访问控制检查的能力。 对于公共成员、默认(打包)访问成员、受保护成员和私有成员,在分别使用 Field、 Method 或 Constructor 对象来设置或获取字段、调用方法,或者创建和初始化类的新实例 的时候,会执行访问检查。常用方法如下:
  • public void setAccessible(boolean flag) throws SecurityException

    参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。参数值 为 false 则指示反射的对象应该实施 Java 语言访问检查。

  • 获取私有构造方法,步骤如下:

    1. 获取到 Class 对象
    2. 获取指定的构造方法
    3. 暴力访问, 通过 setAccessible(booleanflag)方法
    4. 通过构造方法类 Constructor 中的方法,创建对象

    publicTnewInstance(Object…initargs)

示例代码
public class Test04 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // TODO Auto-generated method stub

        Class c = Class.forName("classtry.Student");
        Constructor con1 = c.getDeclaredConstructor(String.class);
        con1.setAccessible(true);//不加这一行会报错!!!
        Object obj1 = con1.newInstance("李四");
        System.out.println(obj1);
    }

}

反射操作属性

通过反射获取成员变量并使用

在反射机制中,把类中的成员变量使用类 Field 表示。可通过 Class 类中提供的方法获取成 员变量:

  • 获取单个成员变量

    publicFieldgetField(Stringname) 获取指定的 public 修饰的变量
    publicFieldgetDeclaredField(Stringname) 获取指定的任意变量

  • 获取多个成员变量

    publicField[]getFields() 获取所有 public 修饰的变量
    publicField[]getDeclaredFields() 获取所有的变量 (包含私有)

示例代码
public class Test05 {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        /*
         * - 获取单个成员变量
         *  > public Field getField(Stringname) 获取指定的 public 修饰的变量 
         *  > public Field getDeclaredField(Stringname) 获取指定的任意变量
         */
        Class c = Class.forName("classtry.Student");
        Field name = c.getField("name");
        System.out.println(name);
        Field adress = c.getDeclaredField("adress");
        System.out.println(adress);
        System.out.println("==============================");
        /*- 获取多个成员变量
         *> public Field[] getFields() 获取所有 public 修饰的变量 
         *> public Field[] getDeclaredFields() 获取所有的变量 (包含私有)
         * 
         */
        Field[] f1 = c.getFields();
        for (Field ff1 : f1) {
            System.out.println(ff1);
        }
        System.out.println("==============================");

        Field[] f2 = c.getDeclaredFields();
        for (Field ff2 : f2) {
            System.out.println(ff2);
        }

    }

}

通过反射,获取指定的成员变量,并赋值

获取成员变量,步骤如下:
1. 获取 Class 对象
2. 获取构造方法
3. 通过构造方法,创建对象
4. 获取指定的成员变量(私有成员变量,通过 setAccessible(booleanflag)方法暴力访问)
5. 通过方法,给指定对象的指定成员变量赋值或者获取值

  • 方法介绍
    publicvoidset(Objectobj,Objectvalue):在指定对象 obj 中,将此 Field 对象表示的成员 变量设置为指定的新值
    publicObjectget(Objectobj):返回指定对象 obj 中,此 Field 对象表示的成员变量的值
示例代码
public class Test06 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub

        /*
         * public void set(Objectobj,Objectvalue):在指定对象 obj 中,
         *          将此 Field 对象表示的成员 变量设置为指定的新值 
         * public Object get(Objectobj):返回指定对象 obj 中,此 Field 对象表示的成员变量的值
         */
        Class c = Class.forName("classtry.Student");
        Object obj = c.getConstructor().newInstance();
        Field name = c.getField("name");
        name.set(obj, "张三");
        System.out.println(obj);
        System.out.println("========================");
        Object nameString = name.get(obj);
        if(nameString instanceof String){
            System.out.println("张三");
        }else{
            System.out.println("李四");
        }   
    }

}

反射操作成员方法

在反射机制中,把类中的成员方法使用类 Method 表示。可通过 Class 类中提供的方法获取 成员

- 获取多个

Method[]getMethods():获取所有”公有方法”(包括继承的)
Method[]getDeclaredMethods():获取所有成员方法(包括私有)

- 获取单个成员方法

MethodgetMethod(Stringname,Class…parameterTypes):获取指定的”公有方法”
MethodgetDeclaredMethod(Stringname,Class…parameterTypes):获取指定的方法,包括 私有的

  • 调用方法:(注意:1.要先创建此类的对象;2.调用私有方法前,要先设置暴力访问)

Method
Objectinvoke(Objectobj,Object…args):调用 Method 所代表的方法
返回值:此 Method 对象调用所代表的方法,所获取的返回值;
形参:
obj:方法所属对象;
args:Method 所代表的那个方法的实参列表

示例代码
public class Test07 {
/**
 * 反射操作成员方法
 * @param args
 * @throws Exception 
 */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        /*
         *  获取多个
         *   Method[]getMethods():获取所有"公有方法"(包括继承的) 
         *   Method[]getDeclaredMethods():获取所有成员方法(包括私有) 
         */  
         Class c = Class.forName("classtry.Student");
         Object obj = c.getConstructor().newInstance();
         Constructor con1 = c.getDeclaredConstructor();
//       con1.setAccessible(true);
         Object obj2 = con1.newInstance();
         Method[] m1 = c.getMethods();
         for (Method method1 : m1) {
            System.out.println(method1);
         }
         System.out.println("===============================");
         Method[] m2 = c.getDeclaredMethods();
         for (Method method2 : m2) {
            System.out.println(method2);
         }
         System.out.println("===============================");
        /*
         * 获取单个成员方法
         * MethodgetMethod(Stringname,Class...parameterTypes):获取指定的"公有方法"
         * MethodgetDeclaredMethod(Stringname,Class...parameterTypes):
         * 获取指定的方法,包括 私有的
         */
         Method m3 = c.getMethod("eat");
         m3.invoke(obj);
         Method m4 = c.getMethod("num",int.class);
         m4.invoke(obj, 3);
         Method m5 = c.getMethod("nums", int.class);
         Object result = m5.invoke(obj, 1);
         System.out.println(result);

         System.out.println("===============================");

         Method m6 = c.getDeclaredMethod("learn",null);
         m6.setAccessible(true);
         m6.invoke(obj2);


    }

}

通过反射创建对象,并调用指定的方法

执行找到的方法

publicObjectinvoke(Objectobj, Object…args)
执行指定对象 obj 中,当前 Method 对象所代表的方法,方法要传入的参数通过 args 指定。

示例代码
public class Test08 {
/**
 * 通过反射创建对象,并调用指定的方法
 * @param args
 * @throws Exception 
 */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub

        /*执行找到的方法 
         * public Object invoke(Objectobj, Object...args) 
         * 执行指定对象 obj 中,当前 Method 对象所代表的方法,方法要传入的参数通过 args 指定。
         */
        Class c = Class.forName("classtry.Student");
        Constructor con = c.getDeclaredConstructor();
//      con.setAccessible(true);
        Object obj = con.newInstance();
        Method m1 = c.getMethod("eat", null);
        m1.invoke(obj);
        Method m2 = c.getDeclaredMethod("study", null);
        m2.setAccessible(true);
        m2.invoke(obj);

    }

}

反射练习

反射运行配置文件内容

  • Properties 介绍
    Properties 继承自 Hashtable,说明其是以键与值的方式存在的,只是 Properties 的 键与值都是必须是字符串类型的数据。Properties 常被用于配置文件的写入与读取, 配置文件中记录着程序的各项参数信息,使用程序的用户可以自定义某些参数,以达到 软件的个性化。

  • 通过反射读取配置文件,可以不改变主程序代码,只要修改配置文件就可以操作不同的 对象执行不同的功能。

示例代码
public class Demo {

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
//      System.out.println(Test02.class);
        Class c = Class.forName(porties("className"));
        Object obj = c.getConstructor().newInstance();
        Method m1 = c.getMethod(porties("methodName"));
        m1.invoke(obj);

    }
    public static String porties(String key) throws Exception{
        Properties p = new Properties();
        FileReader fr = new FileReader("protiesty.properties");
        p.load(fr);
        fr.close();
        return p.getProperty(key);
    }

}
public class Test01 {

    public void show1(){
        System.out.println("这是方法show1");
    }
}
public class Test02 {

    public void show2(){
        System.out.println("这是方法show2");
    }
}
//配置文件中
className = classtrain.Test02
methodName = show2

通过反射越过泛型类型检查

通过反射越过泛型检查,定义一个具有 String 泛型的集合,要求成功向集合中添加一个 int 数据

示例代码
public class Demo2 {

    public static void main(String[] args) throws Exception, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
        // TODO Auto-generated method stub
        List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        //list.add(12345);//该行报错
        Class c = list.getClass();
        //Object obj = c.getConstructor().newInstance();
        Method m1 = c.getMethod("add", Object.class);
        m1.invoke(list, 12435);
        for (Object str : list) {
            System.out.println(str);
        }
    }

}

通用设置属性的方法

通过反射写一个通用的方法,能够设置某个对象的某个属性为指定的值

示例代码
public class Demo3 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Cat c = new Cat();
        usual(c, "name", "123456");
        c.show();

    }
    public static void usual(Object kindName,String filedName,Object value) throws Exception{
        Class c = kindName.getClass();
        Field fname = c.getDeclaredField(filedName);
        fname.setAccessible(true);
        fname.set(kindName, value);
    }

}
public class Cat {

    private String name;
    public void show() {
        // TODO Auto-generated method stub

        System.out.println("瞎、。。。叫"+this.name);
    }
}
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页