Java基础学习笔记二10叁 Java宗旨语法之反射

透过反射获取构造方法并选取

在反射机制中,把类中的成员(构造方法、成员方法、成员变量)都打包成了相应的类进行表示。在这之中,构造方法使用类Constructor表示。可透过Class类中提供的办法获得构造方法:

重回2个构造方法:

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. 通过构造方法,创设对象

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 = 凯利广场

 泛型擦除

将已存在的ArrayList<Integer>集合中增加3个字符串数据,怎么着兑现呢?其实程序编写翻译后发出的.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=中国]
//私有方法

因此反射格局,获取个人构造方法,创设对象

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]

类加载器

担当将.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文件中的内容吗?那正是反射要商量的剧情。

类加载器

透过反射,创立对象,调用钦定的方法

取得成员方法,步骤如下:

  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

反射

JAVA反射机制是在运行意况中,对于随意一个类,都能够掌握那一个类的富有属性和格局;对于自由二个对象,都能够调用它的自由3个办法和属性;那种动态获取的音讯以及动态调用对象的章程的职能称为java语言的反光机制。

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

通过反射,创立对象,调用钦赐的private 方法

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

  1. 获取Class对象

  2. 得到构造方法

  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的构造方法
//私有方法

Class类

翻阅API的Class类得知,Class 未有集体构造方法。Class 对象是在加载类时由
Java 虚拟机以及由此调用类加载器中的 defineClass 方法自动构造的。

赢得Class对象的两种艺术

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

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

办法二: 通过 类名.class
获取到字节码文件对象(任意数据类型都享有二个class静态属性,看上去要比第壹种方式大概)。

Class c2 = Person.class;

主意3: 通过Class类中的方法(将类名作为字符串传递给Class类中的静态方法forName就可以)。

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

前二种你必须旗帜明显Person类型。第1种是内定那种类型的字符串就行.那种扩大越来越强.小编不供给明白您的类.我只提供字符串,依照安顿文件加载就能够了。

代码演示:

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+ "]";
    }
}

因而反射获取成员变量并使用

在反射机制中,把类中的成员变量使用类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

类的加载

当程序要动用某些类时,固然此类还未被加载到内部存款和储蓄器中,则系统会透过加载,链接,开端化三步来贯彻对这一个类举行初步化。

加载正是指将class文件读入内存,并为之创制二个Class对象。任何类被使用时系统都会创立2个Class对象。

链接指的是将Java类的二进制代码合并到JVM的运作情形之中的进程。在链接在此之前,那些类必须被成功加载。类的链接包涵注脚、准备和剖析等多少个步骤。

  • 评释:是或不是有不错的内部结构,并和此外类协调1致。
  • 预备:负责为类的静态成员分配内部存款和储蓄器,并安装暗中认可早先化值
  • 分析:将类的二进制数据中的符号引用替换为直接引用

开端化正是从前讲过的起初化步骤,类初步化时机:

  • 创制类的实例
  • 访问类的静态变量,或然为静态变量赋值
  • 访问类的静态方法
  • 应用反射方式来强制成立有些类或接口对应的java.lang.Class对象
  • 开始化有个别类的子类
  • 直白采取java.exe命令来运作有个别主类

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

在反射机制中,把类中的成员方法应用类Method表示。可透过Class类中提供的点子赢得成员方法:

回去获取五个办法:

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

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

参数一: name 要探索的点子名称; 参数二: 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. 通过构造方法类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=哈尔滨]

相关文章