BootstrapJava基础学习笔记二十三 Java核心语法之反射

恍如加载器

恍如的加载

当次要利用某类时,如果此类还不为加载到内存中,则网会经过加载,链接,初始化三步来贯彻对斯仿佛进行初始化。

加载就是负用class文件读入内存,并为底创建一个Class对象。任何像样让以时系统还见面确立一个Class对象。

链接指的是将Java类的次前进制代码合并到JVM的运作状态里的历程。在链接之前,这个近乎必须让成功加载。类的链接包括证明、准备和分析等几乎独步骤。

  • 说明:是否有不易的内部结构,并和其他类协调一致。
  • 备:负责为类的静态成员分配内存,并设置默认初始化值
  • 分析:将类的二进制数据中之符引用替换为直接引用

初始化就是原先语了之初始化步骤,类初始化时机:

  • 创立类的实例
  • 访问类的静态变量,或者为静态变量赋值
  • 访问类的静态方法
  • 运用反射方式来强制创建有类还是接口对应的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目录。

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

通过这些描述就是足以领略我们经常因此的类似,都是由谁来加载成功的。到目前为止我们已经清楚把class文件加载到内存了,那么,如果我们只是站在这些class文件的角度,我们怎么来利用这些class文件被的情为?这虽是反光而钻之内容。

反射

JAVA反射机制是以运行状态被,对于随意一个近乎,都能明白者仿佛的备属性和方;对于自由一个目标,都能调用它的自由一个计与性能;这种动态获取之信息及动态调用对象的计的功能称为java语言的反光机制。

如果惦记解剖一个接近,必须优先使得到到此类的配节码文件对象。而解剖使用的就是Class类中的方法.所以先要赢得到各级一个配节码文件对应之Class类型的靶子。

Class类

读书API的Class类得知,Class 没有集体构造方法。Class 对象是以加载类时出于
Java 虚拟机暨由此调用类加载器中的 defineClass 方法自动构造之。

得到Class对象的老三栽艺术

方式一: 通过Object类中的getClass()方法

Person p = new Person();
Class c = p.getClass();

主意二: 通过 类名.class
获取到配节码文件对象(任意数据类型都负有一个class静态属性,看上去要于第一种方式大概)。

Class c2 = Person.class;

计三: 通过Class类中之点子(将类名作为字符串传递让Class类中之静态方法forName即可)。

Class c3 = Class.forName(“Person”);

前方片栽你必旗帜鲜明Person类型。第三种植是指定这种类型的字符串就行.这种扩张更强.我莫需掌握乃的类.我光提供字符串,按照部署文件加载就好了。

代码演示:

package typeinfo;

/* 获取.class字节码文件对象的方式
* 1:通过Object类中的getClass()方法
* 2: 通过 类名.class 获取到字节码文件对象
* 3: 反射中的方法,
* public static Class<?> forName(String className) throws ClassNotFoundException
* 返回与带有给定字符串名的类或接口相关联的 Class 对象
*/
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
// 1:通过Object类中的getClass()方法
        Person p1 = new Person();
        Class c1 = p1.getClass();
        System.out.println("c1 = " + c1);
// 2: 通过 类名.class 获取到字节码文件对象
        Class c2 = Person.class;
        System.out.println("c2 = " + c2);
// 3: 反射中的方法
        Class c3 = Class.forName("typeinfo.Person");// 包名.类名
        System.out.println("c3 = " + c3);
    }
}
//c1 = class typeinfo.Person
//c2 = class typeinfo.Person
//c3 = class typeinfo.Person

package typeinfo;
public class Person {
    //成员变量
    public String name;
    public int age;
    private String address;

    //构造方法
    public Person() {
        System.out.println("空参数构造方法");
    }
    public Person(String name) {
        this.name = name;
        System.out.println("带有String的构造方法");
    }
    //私有的构造方法
    private Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有String,int的构造方法");
    }
    public Person(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("带有String, int, String的构造方法");
    }
    //成员方法
    //没有返回值没有参数的方法
    public void method1(){
        System.out.println("没有返回值没有参数的方法");
    }
    //没有返回值,有参数的方法
    public void method2(String name){
        System.out.println("没有返回值,有参数的方法 name= "+ name);
    }
    //有返回值,没有参数
    public int method3(){
        System.out.println("有返回值,没有参数的方法");
        return 123;
    }
    //有返回值,有参数的方法
    public String method4(String name){
        System.out.println("有返回值,有参数的方法");
        return "哈哈" + name;
    }
    //私有方法
    private void method5(){
        System.out.println("私有方法");
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
    }
}

由此反射获取构造方法并使

当照机制被,把看似吃的分子(构造方法、成员方法、成员变量)都打包成了相应之类似进行表示。其中,构造方法使用类Constructor表示。可经Class类中提供的法得到构造方法:

返回一个构造方法:

public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)

归来多单构造方法

public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法
public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)

获构造方法的代码演示:

package typeinfo;

import java.lang.reflect.Constructor;

public class ReflectConstructorDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//获取Class对象
        Class c = Class.forName("typeinfo.Person");//包名.类名
//获取所有的构造方法
//Constructor[] cons = c.getConstructors();
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("------------------------");
//获取一个构造方法
//public Person()
        Constructor con1 = c.getConstructor(null);
        System.out.println(con1);
//public Person(String name)
        Constructor con2 = c.getConstructor(String.class);
        System.out.println(con2);
//private Person(String name, int age)
        Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(con3);
//public Person(String name, int age, String address)
        Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
        System.out.println(con4);
    }
}
//public typeinfo.Person(java.lang.String,int,java.lang.String)
//private typeinfo.Person(java.lang.String,int)
//public typeinfo.Person(java.lang.String)
//public typeinfo.Person()
//        ------------------------
//public typeinfo.Person()
//public typeinfo.Person(java.lang.String)
//private typeinfo.Person(java.lang.String,int)
//public typeinfo.Person(java.lang.String,int,java.lang.String)

透过反射方式,获取构造方法,创建对象

步骤如下:

  1. 获取到Class对象

  2. 得到指定的构造方法

  3. 经构造方法类Constructor中之点子 newInstance ,创建对象

代码演示:

package typeinfo;

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

public class ConstructorDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, 
                       InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {
//1,获取到Class对象
        Class c = Class.forName("typeinfo.Person");//包名.类名
//2,获取指定的构造方法
//public Person()
//Constructor con = c.getConstructor(null);
//public Person(String name, int age, String address)
        Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法类中Constructor的方法,创建对象
//Object obj = con.newInstance(null);
        Object obj = con.newInstance("小明", 22, "哈尔滨");
//显示
        System.out.println(obj);
    }
}
//带有String, int, String的构造方法
//Person [name=小明, age=22, address=哈尔滨]

通过反射方式,获取个人构造方法,创建对象

AccessibleObject 类是 Field、Method 及 Constructor
对象的父类。它提供了用照的对象标记为当运用时取消默认 Java
语言访问控制检查的力。

于集体成员、默认(打包)访问成员、受保障成员和民用成员,在个别下
Field、Method 或 Constructor
对象来设置或取字段、调用方法,或者创造及初始化类的初实例的时段,会执行访问检查。常因此艺术如下:

public void setAccessible(boolean flag) throws SecurityException 

参数值为 true ,则指示反射的目标在动用时该收回 Java
语言访问检查。参数值为 false 则指示反射的靶子应实行 Java
语言访问检查。

 获取个人构造方法,步骤如下:

  1. 获取到Class对象

  2. 博指定的构造方法

  3. 武力访问, 通过setAccessible(boolean flag)方法

  4. 透过构造方法类Constructor中之 newInstance 方法,创建对象

代码演示:

package typeinfo;

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

public class ConstructorDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, 
                                           InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//1,获取到Class对象
        Class c = Class.forName("typeinfo.Person");//包名.类名
//2,获取指定的构造方法
//private Person(String name, int age)
        Constructor con = c.getDeclaredConstructor(String.class, int.class);
//3,暴力反射
        con.setAccessible(true);//取消 Java 语言访问检查
//4,通过构造方法类中的功能,创建对象
        Object obj = con.newInstance("小明", 23);
        System.out.println(obj);
    }
}
//带有String,int的构造方法
//Person [name=小明, age=23, address=null]

经反射获取成员变量并使用

于照机制面临,把看似吃的成员变量使用类Field表示。可通过Class类中提供的章程取得成员变量:

回去一个成员变量

public Field getField(String name) 获取指定的public修饰的变量
public Field getDeclaredField(String name) 获取指定的任意变量(包含私有)

回多个分子变量

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

获成员变量的代码演示:

package typeinfo;

import java.lang.reflect.Field;

public class FieldDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
//获取Class对象
        Class c = Class.forName("typeinfo.Person");
//获取成员变量
//多个变量
//Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-----------------");
//一个变量
//public int age;
        Field ageField = c.getField("age");
        System.out.println(ageField);
//private String address
        Field addressField = c.getDeclaredField("address");
        System.out.println(addressField);
    }
}
//public java.lang.String typeinfo.Person.name
//public int typeinfo.Person.age
//private java.lang.String typeinfo.Person.address
//        -----------------
//public int typeinfo.Person.age
//private java.lang.String typeinfo.Person.address
//
//        Process finished with exit code 0

透过反射,创建对象,获取指定的积极分子变量,进行赋值与博取值操作

取得成员变量,步骤如下:

  1. 获取Class对象

  2. 得到构造方法

  3. 经构造方法,创建对象

4.
赢得指定的成员变量(私有成员变量,通过setAccessible(boolean flag)方法暴力访问)

  1. 经艺术,给指定对象的指定成员变量赋值或者取得值 public void set(Object obj, Object
    value) ,在指定对象obj中,将之 Field
    对象表示的积极分子变量设置也指定的新值。

 public
Object get(Object obj)  返回指定对象obj中,此 Field
对象表示的成员变量的价值。

代码演示:

package typeInfo;

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

/**
 * Created by yang on 2017/7/4.
 */
public class FieldDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
//1,获取Class对象
        Class c = Class.forName("typeInfo.Person");
//2,获取构造方法
//public Person(String name)
        Constructor con = c.getConstructor(String.class);
//3,通过构造方法,创建对象
        Object obj = con.newInstance("小明");
//4,获取指定的成员变量
//public String name;
        Field nameField = c.getField("name");
//public int age;
        Field ageField = c.getField("age");
//private String address;
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true); //取消 Java 语言访问检查
//5,通过方法,给指定对象的指定成员变量赋值或者获取值
        System.out.println("name = "+ nameField.get(obj));
        System.out.println("age = "+ ageField.get(obj));
        System.out.println("address = "+ addressField.get(obj));
//赋值
        ageField.set(obj, 23);
        addressField.set(obj, "凯利广场");
        System.out.println("------------------------");
        System.out.println("name = "+ nameField.get(obj));
        System.out.println("age = "+ ageField.get(obj));
        System.out.println("address = "+ addressField.get(obj));
    }
}
//带有String的构造方法
//name = 小明
//age = 0
//address = null
//------------------------
//name = 小明
//age = 23
//address = 凯利广场

经过反射获取成员方法并应用

每当照机制中,把看似吃的积极分子方法以类Method表示。可经过Class类中提供的章程获得成员方法:

返获取一个方式:

public Method getMethod(String name, Class<?>... parameterTypes)//获取public 修饰的方法

public Method getDeclaredMethod(String name, Class<?>... parameterTypes) // 获取任意的方法,包含私有的

参数1: name 要摸的计名称; 参数2: parameterTypes 该办法的参数类型

回来获取多个措施:

public Method[] getMethods() //获取本类与父类中所有public 修饰的方法
public Method[] getDeclaredMethods() //获取本类中所有的方法(包含私有的)

获取成员方法的代码演示:

package typeInfo;

import java.lang.reflect.Method;

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//获取Class对象
        Class c = Class.forName("typeInfo.Person");
//获取多个方法
//Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-----------------------");
//获取一个方法:
//public void method1()
        Method method = c.getMethod("method1", null);
        System.out.println(method);
//public String method4(String name){
        method = c.getMethod("method4", String.class);
        System.out.println(method);
//私有方法
//private void method5()
        method = c.getDeclaredMethod("method5", null);
        System.out.println(method);
    }
}
//public java.lang.String typeInfo.Person.toString()
//public void typeInfo.Person.method2(java.lang.String)
//public int typeInfo.Person.method3()
//public java.lang.String typeInfo.Person.method4(java.lang.String)
//public void typeInfo.Person.method1()
//private void typeInfo.Person.method5()
//        -----------------------
//public void typeInfo.Person.method1()
//public java.lang.String typeInfo.Person.method4(java.lang.String)
//private void typeInfo.Person.method5()

由此反射,创建对象,调用指定的方法

取成员方法,步骤如下:

  1. 获取Class对象

  2. 获构造方法

  3. 经构造方法,创建对象

  4. 抱指定的点子

  5. 施行找到的主意

 public
Object invoke(Object obj, Object… args)
  ,执行指定对象obj中,当前Method对象所代表的法,方法要传播的参数经args指定。

代码演示:

package typeInfo;

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

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
            InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {

//1, 获取Class对象
        Class c = Class.forName("typeInfo.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
        Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法,创建对象
        Object obj = con.newInstance("小明", 23, "哈尔滨");
//4,获取指定的方法
//public void method1()  没有返回值没有参数的方法
//Method m1 = c.getMethod("method1", null);
//public String method4(String name)
        Method m4 = c.getMethod("method4", String.class);
//5,执行找到的方法
//m1.invoke(obj, null);
        Object result = m4.invoke(obj, "yyb");
        System.out.println("result = " + result);
    }
}

//带有String, int, String的构造方法
//有返回值,有参数的方法
//result = 哈哈yyb

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

得个人成员方法,步骤如下:

  1. 获取Class对象

  2. Bootstrap取构造方法

  3. 透过构造方法,创建对象

  4. 获指定的方式

  5. 开暴力访问

  6. 实施找到的法子

 public
Object invoke(Object obj, Object…
args) ,执行指定对象obj中,当前Method对象所代表的主意,方法要传播的参数经args指定。

代码演示:

package typeInfo;

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

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException,
                           IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {
//1, 获取Class对象
        Class c = Class.forName("typeInfo.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
        Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法,创建对象
        Object obj = con.newInstance("小明", 23, "哈尔滨");
//4,获取指定的方法
//private void method5(){
        Method m5 = c.getDeclaredMethod("method5", null);
//5,开启暴力访问
        m5.setAccessible(true);
//6,执行找到的方法
        m5.invoke(obj, null);
    }
}
//带有String, int, String的构造方法
//私有方法

 泛型擦除

拿已经在的ArrayList<Integer>集合中上加一个字符串数据,如何兑现呢?其实程序编译后有的.class文件被凡从来不泛型约束之,这种场面我们誉为泛型的擦除。那么,我们可以通过反射技术,来成功于出泛型约束的集纳中,添加任意档次的素。

代码如下:

package typeInfo;

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

/**
 * Created by yang on 2017/7/4.
 */
public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
            IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {
        ArrayList<Integer> list = new ArrayList<Integer>();
//添加元素到集合
        list.add(new Integer(30));
        list.add(new Integer("12345"));
        list.add(123);
//list.add("哈哈");//因为有泛型类型的约束
        System.out.println(list);
//通过反射技术,实现添加任意类型的元素
//1, 获取字节码文件对象
//Class c = list.getClass();
//Class c = ArrayList.class;
        Class c = Class.forName("java.util.ArrayList");
//2, 找到add()方法
// public boolean add(E e)
        Method addMethod = c.getMethod("add", Object.class);
//3,  执行add()方法
        addMethod.invoke(list, "哈哈");// list.add("哈哈");
        System.out.println(list);
    }
}
//[30, 12345, 123]
//[30, 12345, 123, 哈哈]

照配置文件

通过反射配置文件,运行配置文件被指定类的呼应措施

读取Peoperties.txt文件被的数,通过反射技术,来完成Person对象的创立,Peoperties.txt(放在src目录下)文件内容如下:

className=typeInfo.Person
methodName=method5

读取配置文件,调用指定类吃的照应措施

package typeInfo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * Created by yang on 2017/7/4.
 */
public class ReflectTest2 {
    public static void main(String[] args)
            throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException,
            InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// 通过Properties集合从文件中读取数据
        Properties prop = new Properties();
// 读取文件中的数据到集合中
        prop.load(new FileInputStream("src/properties.txt"));
// 获取键所对应的值
        String className = prop.getProperty("className");
        System.out.println(className);
// 1,获取Person.class 字节码文件对象
        Class c = Class.forName(className);
// 2,获取构造方法
// public Person(String name, int age, String address)
        Constructor con = c.getConstructor(String.class, int.class, String.class);
// 3,创建对象
        Object obj = con.newInstance("小明", 20, "中国");
        System.out.println(obj);
// 4,获取指定的方法
// private void method5(){}
        String methodName = prop.getProperty("methodName");
        Method m5 = c.getDeclaredMethod(methodName, null);
// 5,开启暴力访问
        m5.setAccessible(true);
// 6,执行找到的方法
        m5.invoke(obj, null);
    }
}

//typeInfo.Person
//带有String, int, String的构造方法
//Person [name=小明, age=20, address=中国]
//私有方法

相关文章