java反射 int_java反射基础知识

Java程序中的对象在运行时会出现两种类型：编译时类型和运行时类型，例如：

Animal a=new Dog();//多态，父类的引用指向子类的对象。在编译时变量a会被认为是Animal类型(父类)，而运行时a会被认为是Dog类型(子类型)。

此外，有的程序在运行时接收外部传入的对象，编译时类型为Object，但运行时需要调用该对象运行时类型的属性或方法。

为解决这种问题，程序需要在运行时发现对象和类的真是信息。Java中有两种方法：

第一种：假设在编译和运行时都完全知道类型的具体信息，则可以通过直接使用instanceof判断，再强制类型转换为运行时的变量。

第二种：编译时无法预知该对象和类型可能属于哪些类，程序只能依靠运行时信息来发现该类和对象的真实信息，在这种情况下，必须使用反射。

反射，是指在java中，在运行期可以载入、探知和使用编译期完全未知的类。

反射的作用：获取类的完整信息、动态创建和操纵对象、调用方法、访问属性、动态创建和访问数组。

在Java程序中有三中获得Class对象的方式：

1.编译期不知道类名，运行期可以获得该类名时，使用Class类的静态方法forName()获得Class对象。

Classcls=Class.forName("全限定名");注意：这种方式必须使用全限定名！

2.编译期知道类名。可以调用该类的class属性获得该类的Class对象。

Class cls=类名.class;这里的类名不一定要使用全限定名，仅仅是类名标识符，如果不同包，则导入类即可，也可以使用全限定名，这样不需要导入类

3.如果已经得到一个类的实例对象，调用该对象的getClass()方法也可以获得该类的Class对象

User user=new User();

Class cls=user.getClass();

在Class类中，通过getFiedls()、getMethods()、getConstructors()方法，可以获得Class所含类的public属性、pulic方法和pulic构造器(返回一个元素类型为Field/Method/Constructor的数组)，可以获取到从父类继承来的属性和方法。而getDeclaredFields()、getDeclaredMethods()、getDeclaredConstructors()可以获得Class包含的类中定义的所有属性、方法和构造器(返回一个元素类型为Field/Method/Constructor的数组)，但是不能获取到从父类继承的属性和方法。在使用时需要根据需要决定调用合适的方法。

在java中创建对象的方式有四种：new、反射、对象克隆、对象反序列化。

一、使用反射生成并操纵对象

反射创建对象的方式有两种：

1.使用Class对象的newInstance()方法创建该类对应的实例，这种方式实际上调用的是默认的构造器，因此要求Class对象对应的类必须有默认的构造器(无参构造器)。

2.先通过Class对象获取指定的Constructor对象(通过给出参数列表)，再调用Constructor对象的newInstance()方法创建该类对应的实例(创建时需要传递对应参数)。

package com.test;

/**测试通过反射创建对象*/

import java.lang.reflect.Constructor;

public class CreateNewObject {

public CreateNewObject(String str) {

System.out.println(str);

}

public CreateNewObject(int a, int b){

System.out.println("a="+a+" b="+b);

}

public static void main(String[] args) {

try {

Class cls=Class.forName("com.test.CreateNewObject");//获得Class对象

Class []paramTypes=new Class[2];//定义参数类型，表示有2个参数

paramTypes[0]=Integer.TYPE;//基础数据类型用.TYPE

paramTypes[1]=Integer.TYPE;

//获取指定的构造器,也可以直接写成cls.getDeclaredConstructor(Integer.TYPE,Integer.TYPE);

Constructor ct=cls.getConstructor(paramTypes);

Object[]arglist=new Object[2];//为newInstance定义参数，这里表示有2个参数

arglist[0]=new Integer(30);

arglist[1]=new Integer(20);

//传递参数，调用指定构造器的newInstance()方法创建实例，也可以直接写成ct.newInstance(Integer.TYPE,Integer.TYPE);

ct.newInstance(arglist);

ct=cls.getConstructor(String.class);

ct.newInstance("调用一个字符串参数的构造器");

} catch (Exception e) {

e.printStackTrace();

}

}

}

运行结果如下：

a=30 b=20

调用一个字符串参数的构造器

二.调用方法

1.获得Class对象

2.通过Class对象的getMethod()或者getDeclaredMethod()方法获得指定的Method对象(根据访问修饰符确定)。这一步需要传递参数，第一个参数为方法名(必填)，第二个及以后的参数表示该方法的参数列表。

参数列表不是必须的，如果一个方法是无参的，那么在获得getMethod()/getDeclaredMethod()时第二个参数可以填null，也可以直接不填，只有一个方法名作为参数，例如：

Class cls=Class.forName(com.Test);//获得Class对象

//获得名为test的无参数的方法的Method对象

cls.getDeclaredMethod("test");//正确

或者cls.getDeclaredMethod("test",null);//也正确

代码如下：

package com.test;

import java.lang.reflect.Method;

//通过反射调用方法

public class ExcuteMethod {

public int add(int a,int b){

return a+b;

}

public String[] test(){

String []strs={"1","2"};

return strs;

}

public static void main(String[] args) {

try {

Class cls=Class.forName("com.test.ExcuteMethod");

Method m=cls.getMethod("add", Integer.TYPE,Integer.TYPE);

ExcuteMethod excMeth=new ExcuteMethod();

//第一个参数必须指定一个对象，用该对象调用方法，第二个参数起直到最后是给定的参数

int a=(int)(m.invoke(excMeth,2,2));//使用反射调用方法的时候返回的是Object类型，需要类型还原,这里只是为了演示，本程序直接打印返回的object对结果没影响

System.out.println(a);

Method m1=cls.getMethod("test",null);

String[]strs=(String[])m1.invoke(excMeth);//把Object类型的对象先还原成数组，之后才能遍历取元素

for (String string : strs) {

System.out.println(string);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

运行结果为如下(打印出了方法返回数组中的每个元素)：

1

2

三、访问属性1.通过Class对象的getField()或者getDeclaredField()方法获得指定的Field对象(根据访问修饰符确定)。这一步需要传递参数，参数为属性名。然后通过Field对象的get(Object obj)方法来访问属性，

参数Object obj表示的是属性所在的实例，即要访问哪一个对象的该属性。通过Field对象的set(Object obj)方法来设置属性，参数Object obj表示的是属性所在的实例，即要设置哪一个对象的该属性。

四。动态创建和访问数组

利用反射机制，可以动态创建数组兵访问数组，java.lang.reflect.Array类提供了创建和访问数组元素的方法，这些方法都是静态的。

综合应用实例：

package com;

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Exercise {

private String name;

private int id;

public Exercise(String str){

System.out.println("在有参构造器内");

}

public String[] test(int a,int b){

String[]strs={String.valueOf(a),String.valueOf(b)};

return strs;

}

public static void main(String[] args) {

try {

//获得Class对象

Class cls=Class.forName("com.Exercise");

//通过Class对象获取构造器

Constructor con=cls.getConstructor(String.class);//注意！没加Declared则只能获取到public修饰的,这里可以用

//调用Constructor的newInstance()方法创建实例

Object e=con.newInstance("哈哈");

//通过Class对象，根据指定的方法名和参数列表获取指定的Method对象

Method m=cls.getMethod("test", Integer.TYPE,Integer.TYPE);//注意int对应的是Integer.TYPE不是Integer.class

//通过Method对象调用方法，需要传入对象和参数

String[]str=(String[])m.invoke(e, 1,2);

for (String string : str) {

System.out.println(string);

}

//通过Class对象获取指定的Field对象

Field name=cls.getDeclaredField("name");//因为属性private必须加上Declared

Field id=cls.getDeclaredField("id");//因为属性private必须加上Declared

//通过Field对象来获取指定的属性，需要传入对象

System.out.println("更改前e的属性:name="+name.get(e)+" id="+id.getInt(e));

//通过Field对象来设置指定的属性，需要传入对象

name.set(e, "zhangsan");

id.set(e, 1);

System.out.println("更改后e的属性:name="+name.get(e)+" id="+id.getInt(e));

//调用Array的静态方法动态创建一个数组，元素类型是int，长度为2

Object arr=Array.newInstance(Integer.TYPE, 2);

//调用Array的静态方法指定数组某个元素的值，参数1是数组，2是索引，3是元素值

Array.set(arr, 1, 123);

//调用Array的静态方法获取数组指定索引位置的元素。参数1是数组，2是索引

System.out.println("数组中索引为1的元素"+Array.get(arr, 1));

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

运行程序，结果为：

在有参构造器内

1

2

更改前e的属性:name=null id=0

更改后e的属性:name=zhangsan id=1

数组中索引为1的元素123

注意：在获得Constructor和Method对象时，如果有参数，那么获取对象时就需要指定参数列表，尤其需要注意参数类型，如果方法中参数为基本数据类型，那么参数就是对应包装类.TYPE，引用数据类型，那么就是类名.class。比如方法声明时参数为int a,那么获取Method对象时参数要写成Integer.TYPE,如果是String str,那么那么获取Method对象时参数要写成String.class。

int.class==Integer.TYPE;true

int.class==Integer.class;false