精华内容
下载资源
问答
  • 对于java反射机制、其实本人开始也不是很理解、只是闲来的时候、偶尔的突发奇想、如果能够直接通过以方法为参数调用方法、那是不是会更方便呢、然后就搜了下资料、无意间就搜到了java的反射机制一些相关信息、而我...

    对于java反射机制、其实本人开始也不是很理解、只是闲来的时候、偶尔的突发奇想、如果能够直接通过以方法为参数调用方法、那是不是会更方便呢、然后就搜了下资料、无意间就搜到了java的反射机制一些相关信息、而我只是想以方法为参数调用方法、然后就进行了一个简单的封装、

    /**

    * 通过类的对象和方法名得到方法对象

    * @param obj 对应方法所在类的实例对象

    * @param methodName 方法名

    * @param clazzs 方法参数类型

    * @return

    * @throws SecurityException

    * @throws NoSuchMethodException

    */

    public static Method getMethod(Object obj,String methodName,Class>... clazzs) throws SecurityException, NoSuchMethodException{

    Method method = obj.getClass().getMethod(methodName, clazzs);

    return method;

    }

    /**

    * 调用某个方法

    * @param obj 对应方法所在类的实例对象

    * @param methodName 方法名

    * @param objs 方法参数

    * @param clazzs 方法参数类型

    * @throws SecurityException

    * @throws NoSuchMethodException

    * @throws IllegalArgumentException

    * @throws IllegalAccessException

    * @throws InvocationTargetException

    */

    public static void invoke(Object obj,String methodName,Object[] objs,Class>[] clazzs) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{

    invoke(obj,getMethod(objs, methodName, clazzs), objs);

    }

    /**

    * 调用某个方法

    * @param obj 对应方法所在类的实例对象

    * @param method 方法

    * @param objs 方法参数

    * @throws IllegalArgumentException

    * @throws IllegalAccessException

    * @throws InvocationTargetException

    */

    public static void invoke(Object obj,Method method,Object... objs) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{

    method.invoke(obj,objs);

    }

    ps:只是做了一个简单的封装、方便个人调用、将代码贴出来方便需要用到这方面的友友们、举一反三、

    展开全文
  • java反射机制调用方法

    千次阅读 2013-07-04 17:13:35
    对于java反射机制、其实本人开始也不是很理解、只是闲来的时候、偶尔的突发奇想、如果能够直接通过以方法为参数调用方法、那是不是会更方便呢、然后就搜了下资料、无意间就搜到了java的反射机制一些相关信息、而我...

    对于java反射机制、其实本人开始也不是很理解、只是闲来的时候、偶尔的突发奇想、如果能够直接通过以方法为参数调用方法、那是不是会更方便呢、然后就搜了下资料、无意间就搜到了java的反射机制一些相关信息、而我只是想以方法为参数调用方法、然后就进行了一个简单的封装、

    	
    	/**
    	 * 通过类的对象和方法名得到方法对象
    	 * @param obj 对应方法所在类的实例对象
    	 * @param methodName 方法名
    	 * @param clazzs  方法参数类型
    	 * @return
    	 * @throws SecurityException
    	 * @throws NoSuchMethodException
    	 */
    	public static Method getMethod(Object obj,String methodName,Class<?>... clazzs) throws SecurityException, NoSuchMethodException{
    		
    		Method method = obj.getClass().getMethod(methodName, clazzs);
    		
    		return method;
    	}
    	
    	/**
    	 * 调用某个方法
    	 * @param obj 对应方法所在类的实例对象
    	 * @param methodName 方法名
    	 * @param objs 方法参数
    	 * @param clazzs 方法参数类型
    	 * @throws SecurityException
    	 * @throws NoSuchMethodException
    	 * @throws IllegalArgumentException
    	 * @throws IllegalAccessException
    	 * @throws InvocationTargetException
    	 */
    	public static void invoke(Object obj,String methodName,Object[] objs,Class<?>[] clazzs) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
    		
    		invoke(obj,getMethod(objs, methodName, clazzs), objs);
    		
    	}
    	
    	/**
    	 * 调用某个方法
    	 * @param obj 对应方法所在类的实例对象
    	 * @param method 方法
    	 * @param objs 方法参数
    	 * @throws IllegalArgumentException
    	 * @throws IllegalAccessException
    	 * @throws InvocationTargetException
    	 */
    	public static void invoke(Object obj,Method method,Object... objs) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
    		
    		method.invoke(obj,objs);
    		
    	}



    ps:只是做了一个简单的封装、方便个人调用、将代码贴出来方便需要用到这方面的友友们、举一反三、


    展开全文
  • 再比如鸭子,可以抽象成一个Duck类,也可以对其进行实例化……那么这一个个类本身是不是也可以抽象成一个类呢?Java提供了一个特殊的类Class,用来描述类的内部信息,是反射的核心类。下图是本篇讲述内容:2. Java...

    1. 前言

    在OOP的世界里,万物皆对象。也就是说,我们可以将任何东西抽象成一个对象。

    比如人,可以抽象成一个Person类,通过new Person()来实例化一个对象;再比如鸭子,可以抽象成一个Duck类,也可以对其进行实例化……那么这一个个类本身是不是也可以抽象成一个类呢?Java提供了一个特殊的类Class,用来描述类的内部信息,是反射的核心类。

    下图是本篇讲述内容:

    ba3a69423463ee651fa8c06d231d839e.png

    2. Java反射机制概述

    Java反射(Reflection)允许应用程序在运行时借助于反射API,来获取所有类或接口的内部信息,并且能直接操作任意对象的内部属性及方法。反射机制的核心类为java.lang.Class。类加载完后,会在堆内存的方法区中产生一个Class类型的对象。

    Class类没有公开的构造函数,是由类加载器的defineClass方法构造而成。所以Class对象不是“new”出来的,而是通过方法来获取的。

    这个Class对象具有类的完整结构信息,并且一个类只有一个Class对象。

    3. 获取Class对象

    获取Class对象有以下四种方式:通过类对象获取;

    通过类直接调用class获取;

    通过Class.forName获取;

    通过类加载器获取。

    下面使用代码展示获取 Person 类的Class对象的四种方式:@Test

    public void testClassFor() {

    // 1.通过类实例获取

    Person person = new Person();

    Class extends Person> clazz1 = person.getClass();

    System.out.println("01 - " + clazz1);

    // 2.通过类直接调用class获取

    Class clazz2 = Person.class;

    System.out.println("02 - " + clazz2);

    // 3.通过Class.forName获取

    Class> clazz3 = null;

    try {

    clazz3 = Class.forName("io.github.gozhuyinglong.reflection.Person");

    } catch (ClassNotFoundException e) {

    // 当找不到指定类时,会抛出此异常

    e.printStackTrace();

    }

    System.out.println("03 - " + clazz3);

    // 4.通过类加载器获取

    ClassLoader classLoader = this.getClass().getClassLoader();

    Class> clazz4 = null;

    try {

    clazz4 = classLoader.loadClass("io.github.gozhuyinglong.reflection.Person");

    } catch (ClassNotFoundException e) {

    // 当找不到指定类时,会抛出此异常

    e.printStackTrace();

    }

    System.out.println("04 - " + clazz4);

    // hashCode相等,说明这四种方式获取的是同一个实例

    System.out.println("05 - " + clazz1.hashCode());

    System.out.println("06 - " + clazz2.hashCode());

    System.out.println("07 - " + clazz3.hashCode());

    System.out.println("08 - " + clazz4.hashCode());

    }

    输出结果:01 - class io.github.gozhuyinglong.reflection.Person

    02 - class io.github.gozhuyinglong.reflection.Person

    03 - class io.github.gozhuyinglong.reflection.Person

    04 - class io.github.gozhuyinglong.reflection.Person

    05 - 721748895

    06 - 721748895

    07 - 721748895

    08 - 721748895

    通过上面的输出结果可以看出,这四个Class对象的hashCode相同,说明使用这四种方式获取的是同一个对象。

    4. 一些特殊的类和接口的Class对象

    在源码注释中提到一些特殊的类和接口:枚举是一种类。

    注解是一种接口。

    数组也属于一个反映为Class对象的类。具有相同元素类型和维数的数组,也具有相同的Class对象(也就是说,元素类型不同,或数组维数不同,其Class对象也不同)。

    原始Java类型(boolean, byte, char, short, int, long, float,double)和关键字 void 也表示为Class对象。

    下面通过代码来验证:@Test

    public void testClassOther() {

    // 枚举是一种类

    Class clazz1 = PersonEnum.class;

    System.out.println("01 - " + clazz1);

    // 注解是一种接口

    Class clazz2 = PersonAnnotation.class;

    System.out.println("02 - " + clazz2);

    // 数组也属于一个反应 Class 实例的类

    Person[] personArray3 = new Person[1];

    Class extends Person[]> clazz3 = personArray3.getClass();

    System.out.println("03 - " + clazz3);

    // 具有相同元素类型和维数的数组,也具有相同的 Class 实例

    Person[] personArray4 = new Person[4];

    Class> clazz4 = personArray4.getClass();

    Person[][] personArray5 = new Person[1][];

    Class> clazz5 = personArray5.getClass();

    // 两个一维数组的 hashCode 相等,说明是同一实例

    System.out.println("04 - " + clazz3.hashCode());

    System.out.println("05 - " + clazz4.hashCode());

    // 一维数组与二维数组的 hashCode 不相等,说明不是同一实例

    System.out.println("06 - " + clazz5.hashCode());

    // 原始 Java 类型和关键字 void 也表示为 Class 实例

    Class clazz6 = int.class;

    System.out.println("07 - " + clazz6);

    Class clazz7 = double.class;

    System.out.println("08 - " + clazz7);

    Class clazz8 = void.class;

    System.out.println("09 - " + clazz8);

    }

    输出结果:01 - class io.github.gozhuyinglong.reflection.PersonEnum

    02 - interface io.github.gozhuyinglong.reflection.PersonAnnotation

    03 - class [Lio.github.gozhuyinglong.reflection.Person;

    04 - 721748895

    05 - 721748895

    06 - 1642534850

    07 - int

    08 - double

    09 - void

    通过输出结果可以看出,确如源码中描述那样。

    5. Java反射API

    Java提供了一套反射API,该API由Class类与java.lang.reflect类库组成。该类库包含了Field、Method、Constructor等类。这些类型的对象是由JVM在运行时创建的,用以表示未知类里对应的成员。

    反射允许以编程的方式访问已加载类的字段、方法和构造函数信息,并在安全限制内利用反射对其进行操作。

    下面将介绍一些常用的类:

    5.1 Class(类)

    java.lang.Class类用来描述类的内部信息,Class的实例可以获取类的包、注解、修饰符、名称、超类、接口等。@Test

    public void testClass() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取该类所在包路径

    Package aPackage = clazz.getPackage();

    System.out.println("01 - " + aPackage);

    // 获取该类上所有注解

    Annotation[] declaredAnnotations = clazz.getDeclaredAnnotations();

    for (Annotation temp : declaredAnnotations) {

    System.out.println("02 - " + temp);

    }

    // 获取类上的修饰符

    int modifiers = clazz.getModifiers();

    String modifier = Modifier.toString(modifiers);

    System.out.println("03 - " + modifier);

    // 获取类名称

    String name = clazz.getName();

    System.out.println("04 - " + name);

    // 获取简单类名

    String simpleName = clazz.getSimpleName();

    System.out.println("05 - " + simpleName);

    // 获取直属超类

    Type genericSuperclass = clazz.getGenericSuperclass();

    System.out.println("06 - " + genericSuperclass);

    // 获取直属实现的接口

    Type[] genericInterfaces = clazz.getGenericInterfaces();

    for (Type temp : genericInterfaces) {

    System.out.println("07 - " + temp);

    }

    }

    输出结果:01 - package io.github.gozhuyinglong.reflection

    02 - @io.github.gozhuyinglong.reflection.PersonAnnotation()

    03 - public final

    04 - io.github.gozhuyinglong.reflection.Person

    05 - Person

    06 - class io.github.gozhuyinglong.reflection.PersonParent

    07 - interface io.github.gozhuyinglong.reflection.PersonInterface

    5.2 Constructor(构造函数)

    java.lang.reflect.Constructor提供了类的构造函数信息。可以获取构造函数上的注解信息、参数类型等。@Test

    public void testConstructor() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个声明为 public 构造函数实例

    Constructor> constructor1 = clazz.getConstructor(String.class, int.class, PersonEnum.class);

    System.out.println("01 - " + constructor1);

    // 获取所有声明为 public 构造函数实例

    Constructor>[] constructorArray1 = clazz.getConstructors();

    for (Constructor> constructor : constructorArray1) {

    System.out.println("02 - " + constructor);

    }

    // 获取一个声明的构造函数实例

    Constructor> constructor2 = clazz.getDeclaredConstructor(String.class);

    System.out.println("03 - " + constructor2);

    // 获取所有声明的构造函数实例

    Constructor>[] constructorArray2 = clazz.getDeclaredConstructors();

    for (Constructor> constructor : constructorArray2) {

    System.out.println("04 - " + constructor);

    }

    // 根据构造函数创建一个实例

    Object o1 = constructor1.newInstance("杨过", 25, PersonEnum.MAN);

    System.out.println("05 - " + o1);

    // 将构造函数的可访问标志设为 true 后,可以通过私有构造函数创建实例

    constructor2.setAccessible(true);

    Object o2 = constructor2.newInstance("小龙女");

    System.out.println("06 - " + o2);

    // 获取该构造函数上的所有注解

    Annotation[] annotations = constructor1.getDeclaredAnnotations();

    for (Annotation annotation : annotations) {

    System.out.println("07 - " + annotation);

    }

    // 获取该构造函数上的所有参数类型

    Type[] genericParameterTypes = constructor1.getGenericParameterTypes();

    for (Type genericParameterType : genericParameterTypes) {

    System.out.println("08 - " + genericParameterType);

    }

    }

    输出结果:01 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)

    02 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)

    02 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int)

    02 - public io.github.gozhuyinglong.reflection.Person()

    03 - private io.github.gozhuyinglong.reflection.Person(java.lang.String)

    04 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)

    04 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int)

    04 - private io.github.gozhuyinglong.reflection.Person(java.lang.String)

    04 - public io.github.gozhuyinglong.reflection.Person()

    05 - Person{name='杨过', age=25, sex='MAN'}

    06 - Person{name='小龙女', age=0, sex='null'}

    07 - @io.github.gozhuyinglong.reflection.PersonAnnotation()

    08 - class java.lang.String

    08 - int

    08 - class io.github.gozhuyinglong.reflection.PersonEnum

    5.3 Field(属性)

    java.lang.reflect.Field提供了类的属性信息。可以获取属性上的注解、修饰符、属性类型、属性名等。@Test

    public void testField() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个该类或父类中声明为 public 的属性

    Field field1 = clazz.getField("hobby");

    System.out.println("01 - " + field1);

    // 获取该类及父类中所有声明为 public 的属性

    Field[] fieldArray1 = clazz.getFields();

    for (Field field : fieldArray1) {

    System.out.println("02 - " + field);

    }

    // 获取一个该类中声明的属性

    Field field2 = clazz.getDeclaredField("name");

    System.out.println("03 - " + field2);

    // 获取该类中所有声明的属性

    Field[] fieldArray2 = clazz.getDeclaredFields();

    for (Field field : fieldArray2) {

    System.out.println("04 - " + field);

    }

    // 获取该属性上的所有注解

    Annotation[] declaredAnnotations = field2.getDeclaredAnnotations();

    for (Annotation declaredAnnotation : declaredAnnotations) {

    System.out.println("05 - " + declaredAnnotation);

    }

    // 获取修饰符

    String modifier = Modifier.toString(field2.getModifiers());

    System.out.println("06 - " + modifier);

    // 获取属性类型,返回类对象

    Class> type = field2.getType();

    System.out.println("07 - " + type);

    // 获取属性类型,返回Type对象

    Type genericType = field2.getGenericType();

    System.out.println("08 - " + genericType);

    // 获取属性名称

    String name = field2.getName();

    System.out.println("09 - " + name);

    }

    输出结果:01 - public java.lang.String io.github.gozhuyinglong.reflection.PersonParent.hobby

    02 - public int io.github.gozhuyinglong.reflection.Person.height

    02 - public java.lang.String io.github.gozhuyinglong.reflection.PersonParent.hobby

    03 - private java.lang.String io.github.gozhuyinglong.reflection.Person.name

    04 - private java.lang.String io.github.gozhuyinglong.reflection.Person.name

    04 - private int io.github.gozhuyinglong.reflection.Person.age

    04 - public int io.github.gozhuyinglong.reflection.Person.height

    05 - @io.github.gozhuyinglong.reflection.PersonAnnotation()

    06 - private

    07 - class java.lang.String

    08 - class java.lang.String

    09 - name

    5.4 Method(方法)

    java.lang.reflect.Method提供了类的方法信息。可以获取方法上的注解、修饰符、返回值类型、方法名称、所有参数。@Test

    public void testMethod() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个该类及父类中声明为 public 的方法,需要指定方法的入参类型

    Method method = clazz.getMethod("setName", String.class);

    System.out.println("01 - " + method);

    // 获取该类及父类中所有声明为 public 的方法

    Method[] methods = clazz.getMethods();

    for (Method temp : methods) {

    System.out.println("02 - " + temp);

    }

    // 获取一个在该类中声明的方法

    Method declaredMethod = clazz.getDeclaredMethod("display");

    System.out.println("03 - " + declaredMethod);

    // 获取所有在该类中声明的方法

    Method[] declaredMethods = clazz.getDeclaredMethods();

    for (Method temp : declaredMethods) {

    System.out.println("04 - " + temp);

    }

    // 获取该方法上的所有注解

    Annotation[] declaredAnnotations = method.getDeclaredAnnotations();

    for (Annotation temp : declaredAnnotations) {

    System.out.println("05 - " + temp);

    }

    // 获取修饰符

    String modifier = Modifier.toString(method.getModifiers());

    System.out.println("06 - " + modifier);

    // 获取返回值类型,返回类对象

    Class> returnType = method.getReturnType();

    System.out.println("07 - " + returnType);

    // 获取返回值类型,返回Type对象

    Type genericReturnType = method.getGenericReturnType();

    System.out.println("08 - " + genericReturnType);

    // 获取方法名称

    String name = method.getName();

    System.out.println("09 - " + name);

    // 获取所有入参

    Parameter[] parameters = method.getParameters();

    for (Parameter temp : parameters) {

    System.out.println("10 - " + temp);

    }

    }

    输出结果:01 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)

    02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.toString()

    02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.getName()

    02 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)

    02 - public int io.github.gozhuyinglong.reflection.Person.getAge()

    02 - public void io.github.gozhuyinglong.reflection.Person.setAge(int)

    02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.sayHello()

    02 - public io.github.gozhuyinglong.reflection.PersonEnum io.github.gozhuyinglong.reflection.PersonParent.getSex()

    02 - public void io.github.gozhuyinglong.reflection.PersonParent.setSex(io.github.gozhuyinglong.reflection.PersonEnum)

    02 - public final void java.lang.Object.wait() throws java.lang.InterruptedException

    02 - public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException

    02 - public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException

    02 - public boolean java.lang.Object.equals(java.lang.Object)

    02 - public native int java.lang.Object.hashCode()

    02 - public final native java.lang.Class java.lang.Object.getClass()

    02 - public final native void java.lang.Object.notify()

    02 - public final native void java.lang.Object.notifyAll()

    03 - private java.lang.String io.github.gozhuyinglong.reflection.Person.display()

    04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.toString()

    04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.getName()

    04 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)

    04 - private java.lang.String io.github.gozhuyinglong.reflection.Person.display()

    04 - public int io.github.gozhuyinglong.reflection.Person.getAge()

    04 - public void io.github.gozhuyinglong.reflection.Person.setAge(int)

    04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.sayHello()

    05 - @io.github.gozhuyinglong.reflection.PersonAnnotation()

    06 - public

    07 - void

    08 - void

    09 - setName

    10 - java.lang.String arg0

    5.5 Modifier(修饰符)

    java.lang.reflect.Modifier提供了访问修饰符信息。通过Class、Field、Method、Constructor等对象都可以获取修饰符,这个访问修饰符是一个整数,可以通过Modifier.toString方法来查看修饰符描述。并且该类提供了一些静态方法和常量来解码访问修饰符。@Test

    public void testModifier() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取类的修饰符值

    int modifiers1 = clazz.getModifiers();

    System.out.println("01 - " + modifiers1);

    // 获取属性的修饰符值

    int modifiers2 = clazz.getDeclaredField("name").getModifiers();

    System.out.println("02 - " + modifiers2);

    // 获取构造函数的修饰符值

    int modifiers3 = clazz.getDeclaredConstructor(String.class).getModifiers();

    System.out.println("03 - " + modifiers3);

    // 获取方法的修饰符值

    int modifiers4 = clazz.getDeclaredMethod("display").getModifiers();

    System.out.println("04 - " + modifiers4);

    // 判断修饰符值是否 final 类型

    boolean isFinal = Modifier.isFinal(modifiers1);

    System.out.println("05 - " + isFinal);

    // 判断修饰符值是否 public 类型

    boolean isPublic = Modifier.isPublic(modifiers2);

    System.out.println("06 - " + isPublic);

    // 根据修饰符值,获取修饰符标志的字符串

    String modifier = Modifier.toString(modifiers1);

    System.out.println("07 - " + modifier);

    System.out.println("08 - " + Modifier.toString(modifiers2));

    }

    输出结果:01 - 17

    02 - 2

    03 - 2

    04 - 2

    05 - true

    06 - false

    07 - public final

    08 - private

    5.6 Parameter(参数)

    java.lang.reflect.Parameter提供了方法的参数信息。可以获取方法上的注解、参数名称、参数类型等。@Test

    public void testParameter() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取构造函数的参数

    Constructor> constructor = clazz.getConstructor(String.class, int.class, PersonEnum.class);

    Parameter[] parameterArray1 = constructor.getParameters();

    for (Parameter temp : parameterArray1) {

    System.out.println("01 - " + temp);

    }

    // 获取方法的参数

    Method method = clazz.getMethod("setName", String.class);

    Parameter[] parameterArray2 = method.getParameters();

    for (Parameter temp : parameterArray2) {

    System.out.println("02 - " + temp);

    }

    Parameter parameter = parameterArray1[0];

    // 获取参数上的注解

    Annotation[] annotationArray = parameter.getAnnotations();

    for (Annotation temp : annotationArray) {

    System.out.println("02 - " + temp);

    }

    // 获取参数名称

    String name = parameter.getName();

    System.out.println("03 - " + name);

    // 获取参数类型

    Type parameterizedType = parameter.getParameterizedType();

    System.out.println("04 - " + parameterizedType);

    Class> type = parameter.getType();

    System.out.println("05 - " + type);

    }

    输出结果:01 - java.lang.String arg0

    01 - int arg1

    01 - io.github.gozhuyinglong.reflection.PersonEnum arg2

    02 - java.lang.String arg0

    02 - @io.github.gozhuyinglong.reflection.PersonAnnotation()

    03 - arg0

    04 - class java.lang.String

    05 - class java.lang.String

    5.7 AccessibleObject(可访问标志)

    java.lang.reflect.AccessibleObject类是Field、Method和Constructor类的超类。

    该类提供了对类、方法、构造函数的访问控制检查的能力(如:私有方法只允许当前类访问)。

    该访问检查在设置/获取属性、调用方法、创建/初始化类的实例时执行。

    可以通过setAccessible方法将可访问标志设为true(默认为false),会关闭访问检查。这样即使是私有的属性、方法或构造函数,也可以访问。

    6. 通过反射动态创建对象并执行方法

    可以利用反射来创建对象,并可执行方法,下面看代码示例:通过Class类的newInstance创建一个实例。(该方法调用无参构造器)。

    通过构造函数Constructor类创建一个实例。

    获取方法,再通过 invoke 方法来调用,第一个参数为实例,后面参数为方法的Parameter。

    获取字段,因为 age 字段是私有的,所以将其设置为可访问(不设置会报异常)。并通过 set 方法来赋值。@Test

    public void testInvoke() throws Exception {

    Class> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 通过Class类的newInstance创建一个实例。(该方法调用无参构造器)

    Object o1 = clazz.newInstance();

    System.out.println("01 - " + o1.toString());

    // 通过构造函数Constructor类创建一个实例

    Constructor> constructor = clazz.getConstructor(String.class, int.class, PersonEnum.class);

    Object o2 = constructor.newInstance("杨过", 25, PersonEnum.MAN);

    System.out.println("02 - " + o2.toString());

    // 先获取方法,再通过 invoke 方法来调用,第一个参数为实例,后面参数为方法的Parameter

    Method method = clazz.getMethod("setName", String.class);

    method.invoke(o1, "小龙女");

    System.out.println("03 - " + o1.toString());

    // 获取字段,因为 age 字段是私有的,所以将其设置为可访问(不设置会报异常)。并通过 set 方法来赋值

    Field field = clazz.getDeclaredField("age");

    field.setAccessible(true);

    field.set(o1, 28);

    System.out.println("04 - " + o1.toString());

    }

    执行结果:01 - Person{name='null', age=0, sex='null'}

    02 - Person{name='杨过', age=25, sex='MAN'}

    03 - Person{name='小龙女', age=0, sex='null'}

    04 - Person{name='小龙女', age=28, sex='null'}

    7. 反射的缺点

    反射虽是强大的,但不可随意使用。如果可以在不使用反射的情况下执行操作,则应避免使用它。因为通过反射访问代码时,会有以下缺点。

    7.1 性能开销

    反射包括了一些动态类型,所以JVM无法对这些代码进行优化。因此,反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。

    7.2 安全限制

    使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行,如Applet,那么这就是个问题了。

    7.3 内部暴露

    由于反射允许代码执行一些在正常情况下不被允许的操作,比如访问私有的属性和方法。所以使用反射可能会导致意料之外的副作用:代码有功能上的错误,降低可移植性。反射代码破坏了抽象性,因此当平台发生改变的时候,代码的行为就有可能也随着变化。

    8. 完整代码

    完整代码请访问我的Github,若对你有帮助,欢迎给个⭐,感谢~~🌹🌹🌹

    9. 参考资料

    展开全文
  • 简单来说,反射就是使用动态的方式,创建对象调用方法,访问属性。 java中反射的使用都是从内置的Class对象开始的。每个类创建好之后都会生成一个Class对象。 Class对象获取的三种方式 package ...

    反射

    反射是什么 有什么用

    反射是动态语言的基本特征。java是不是动态语言?所谓动态语言就是在代码的运行期才知道变量的类型。java是
    静态语言,在反射之前是做不了动态的创建对象这种事的。在jdk1.4之后出现了反射机制,用反射来实现动态语言
    的特性。简单来说,反射就是使用动态的方式,创建对象,调用方法,访问属性。
    java中反射的使用都是从内置的Class对象开始的。每个类创建好之后都会生成一个Class对象。

    Class对象获取的三种方式

    package com.aaa.reflect.entity;
    
    public class Person2 {
    		public static void main(String[] args) throws Exception { 
    			//第一种方式,通过调用Class.forName方法 
    			Class clazz1 = Class.forName("com.aaa.reflect.entity.Person2"); 
    			System.out.println(clazz1); 			  	 
    			//第二种方式 通过调用来的class对象 
    			Class clazz2 = Person2.class; System.out.println(clazz2); 
    			//第三种方式 通过调用对象的getClass方法 
    			Person2 p= new Person2(); Class clazz3 = p.getClass(); 		  
    			System.out.println(clazz3); 
    		}
     }
    
    展开全文
  • 属性注入使用beanwrap对象提供的设置属性的方法,那是不是对象实例化用到反射,属性注入没有用到反射</p>
  • _init__方法2.__str__方法3.__repr__方法4.__del__方法5.__call__方法6.__new__方法7.__eq__方法8.__hash__方法二、类的常用函数1.issubclass():判断一个类是不是其他类的子类2.isinstance():检测一个对象是否为...
  • 学习尚硅谷笔记: 1.疑问1:有两种可以调用公共的结构:new的方式和反射的...首先分析什么是面向对象的封装性,其主要体现是将属性和方法设置为私有的使其在其他类中调用时无法访问该类中内部的私有属性和私有方法。.
  • 反射

    2019-03-05 09:53:45
    在说反射之前,我们先来思考一个具有争议的问题: Java到底是不是纯面向...我们是不能通过a调用一个方法的,所以会有人说Java不是纯面向对象的语言。但其实Java就是一个纯面向对象的语言,因为基本类型它又有包装类...
  • Java反射机制详解上篇

    2017-08-19 18:17:57
    这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。在面向对象的世界里,万事万物皆对象.在java语言里,静态的成员,普通数据类型是不是对象呢?类又是谁的对象呢?首先类是对象,类是java.lang....
  • 这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。 看了之后是不是不懂,其实刚开始我也是。之后看了别人的blog特总结了一下,主要是要在java运行时,而不是编译时,因
  • JAVA基础---反射

    2016-09-06 22:44:51
    这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。 换句话说就是:给我一个类路径或者一个对象,我能得到它的所有信息,以及调用它!!是不是很霸气感觉?确实是的。 三大常用类:Class ...
  • Hello,各位小伙伴是不是对于Java面试很头疼呢?我以前跟你们一样也是如此,今天我给大家分享...这种动态获取类和对象的信息,以及动态调用对象方法的功能被称为Java语言的反射机制。反射的应用在Java中对象主要...
  • java反射机制

    2021-01-18 21:49:21
    java反射机制 反射机制允许程序在执行期借助于Reflection API去的...反射机制与面向对象中的封装性是不是有矛盾的? 不矛盾。 通过直接new的方式或反射的方式都可以调用公共的结构,开发中到底用哪个 直接用new的方式。
  • Java反射机制

    2017-06-02 20:16:07
    对于任意一个对象,都能够调用它的任意一个属性和方法(包括私有的,是不是好可怕,没有隐私了。。);这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 二、 反射机制主要的功能 在运行...
  • 因为我想弄一个调用对象中随机一个方法的效果。资源下载请问怎么实现这个? java反射 Classclass=Class.forName("包名.类名"); Method[]methods=class.getDecaredMethods(); 这个Methods[]数组是自定义的么?用...
  • Java的反射

    2020-08-28 16:00:15
    java反射概述 Java反射机制提供的功能 在运行时判断任意一个对象所属的类 ...疑问2:反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术? 不矛盾。 关于java.Lang.Class类的理解 1.类的加载过程: 程序经
  • 浅析Java反射

    2020-07-30 18:38:28
    根据这些动态获取的信息创建对象、访问/修改成员、调用方法。 一般的数据操作是是依赖于数据类型的 使用new关键字创建相应类型的对象 new Cat(); 根据类型来定义变量。类可以是基本类型、类、接口、数组 Cat cat; ...
  • Hello,各位小伙伴是不是对于Java面试很头疼呢?我以前跟你们一样也是如此,今天我给大家分享...这种动态获取类和对象的信息,以及动态调用对象方法的功能被称为Java语言的反射机制。反射的应用在Java中对象主要...
  • 反射发出--Emit

    2016-05-19 18:11:13
    我们知道反射的主要功能是获得对象的信息、调用对象方法等;而反射发出的主要功能是动态的创建对象。那么是不是二者就没有关系呢?事实上二者不经有关系而且关系十分密切。从命名空间我们就可以看出来...
  • 反射机制的应用

    2017-05-27 13:07:49
    前两天朋友(小许)问我,为什么要用反射反射都用哪些地方应用到,还有就是Struts框架用反射是不是多此一举,所以今天我腾出时间,就这几个问题做个系统的回答。...然后,可以调用类型的方法或访问其字段和属性”–
  • Java反射——框架设计的灵魂

    千次阅读 2018-05-21 21:49:51
    这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 获取Class类的实例对象的三种方式 在面向对象的世界里,万事万物皆对象。(java语言中,静态的成员、普通数据类型除外) 类是不是对象呢?...
  • 六、反射 反射的主要用途 反射的基本使用 ...对于任何一个对象,都能够调用他的任何一个方法和属性(这种说法不正确,我之前调用private方法时就报错。必须要在前面设置一下权限才能使用)。这...
  • 反射机制详解

    千次阅读 多人点赞 2013-01-10 00:11:35
    反射基石--Class类,首字母大写;这是一个类;反射就是把java类中各种成分映射成相应的java类。 java程序中的各种java类,...对于任意一个对象,都能够调用它的任意一个方法;这种动态获取的信息以及动态调用对象的方
  • 反射简介及简单应用

    2021-04-04 08:20:17
    反射 有关程序及其类型的数据被...动态创建类并调用方法 先抛开反射这些乱七八糟的东西,我们来想想看:当你打开了游戏充值页面想要变强的时候,界面是不是有很多个选项?支付宝付款,微信支付,银行卡支付,应有尽.

空空如也

空空如也

1 2 3 4
收藏数 65
精华内容 26
关键字:

对象调用方法是不是反射