java反射class

‘壹’ 什么是java的反射

Java反射指的是对于任何的一个java类，我们都可以通过反射获取到这个类的所有属性和方法(包含私有的属性方法)，使用java反射我们也可以调用一个对象的任何方法。
我们知道Java是一门面向对象编程的语言，我们编程的时候，经常会将类的属性进行封装，然后提供public方法进行属性的设置和获取。类的属性我们通常会设置成private的私有属性，为的就是保护对象属性不被随意的修改和访问。但是反射机制却恰恰相反，通过反射，我们可以获取到这些被保护的属性和方法，并且可以修改和访问他们。
在java中我们可以使用object对象的getClass();方法获得Class的对象classObject;语法格式为 Class classObject = object.getClass() ;可以根据Class对象的方法获取object对象的相关属性和方法;
获取object对象的名字可以使用 classObject.getName();获取类的名称，获取到的结果包含包的名称;
获取object对象的包名称，可以使用classObject.getPackage();获取包的名称;
获取object对象的所有public属性，可以使用classObject.getFields();方法，返回列表是属性类Field[]对象列表;
获取object对象所有属性,可以使用classObject.getDeclaredFields();方法，返回的是所有属性列表(包含private属性);
获取object对象某个特定的属性,可以使用classObject.getField( fieldName );可以根据属性名称获取属性类的对象;
获取object对象private属性，可以使用classObject.getDeclaredField( fieldName );根据属性名获取属性对象信息;
获取object对象public方法，使用classObject.getMethods();可以获取到方法类Method[]对象列表;
获取object对象某个特定的public方法，使用classObject.getMethod( funName , Class... parameterTypes);根据方法名和方法参数类型列表，可以获取到方法类的对象;
获取object对象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以获取所有的方法对象列表;
获取object对象某个特定方法(包含private方法)，使用classObject.getDeclaredMethod ( funName, Class... parameterTypes );根据方法名和方法参数类型列表，可以获取到类的特定方法(包含private方法);
获取object对象类中所有的public构造方法，可以使用classObject.getConstructors(); 获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法，可以使用classObject.getConstructor( Class... parameterTypes ); 根据参数类型列表，获取指定的构造函数对象;
获取object对象类中所有的构造方法(包含private)，可以使用classObject.getDeclaredConstructors(); 获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法(包含private)，可以使用classObject.getDeclaredConstructor( Class... parameterTypes ); 根据参数类型列表，获取指定的构造函数对象;

‘贰’ 什么是反射什么Java反射

java反射是什么意思呢？下面带大家了解一下。
JAVA反射是指程序可以访问、检测和修改它本身状态或行为的一种能力。反射是一种强大的工具，能够创建灵活的代码，可以使代码在运行时装配，无需在组件之间进行源代表链接。
JAVA反射机制是在运行状态中，知道所有属性和方法，对于任意一个对象，能够调用它的方法和属性，这种动态获取的信息以及动态调用对象的方法的功能的反射机制。
反射适合用在哪

首先我们先思考一个问题，反射适合使用在哪里呢？从功能上看，反射似乎无所不能，几乎所有的类，所有的属性、方法、构造我们都能使用，但是我们细细思考一下，在实际开发中，并不是所有场景都需要使用反射获取属性或者方法进行操作，反而更多的使用实例.xxx方式操作，而当这些操作重复次数较多的时候，我们往往会考虑优化代码，减少代码冗余，提高复用，比如实体构建赋值等操作，这个时候往往是我们最需要复用的地方，所以我们可以大体认为反射主要使用在实体操作过程中。而在一般操作数据的过程中，我们的实体一般都是知道并且依赖于对应的数据类型的，比如:
1.根据类型new的方式创建对象
2.根据类型定义变量，类型可能是基本类型也可能是引用类型、类或者接口
3.将对应类型的对象传递给方法
4.根据类型访问对象的属性，调用方法等操作
以上这些操作都是数据操作的过程中最常见也是最难复用优化的地方，而如果这里的操作使用反射则可以实现动态的操作不同的类型的实例，通过调用反射入口类Class，获取对应的属性、构造、方法完成对应的操作

‘叁’ Java反射里面 Type 与Class 的作用有什么不同

1: 类型的概念
概念：类型刻划了一组值及其上可施行的操作，可理解为值集和操作集构成的二元组。

类型的概念与值的概念相对立，前者是程序中的概念，后者则是程序运行时的概念，两者通过标识值的语言成分(例如，变量、表达式等)联系起来。

比如变量v说明为具有类型T，类型T所刻划的值集为{v1，v2，…vn，…}，则变量v运行时能取且只能取某个vi为值。由此可见，类型规定了具有该类型的变量或表达式的取值范围。

2: 类与类型

A: 共性

在对象式语言中，“值”为对象(或对象指引，但本质上仍为对象)。所以，对象式语言中的类型刻划了一组对象及其上可施行的操作。类型所刻划的对象称为类型的实例。类也刻划了一组对象。
两者的共性在于二者均刻划了一组对象及其上的操作(在前面关于类的讨论中，并未强调类刻划对象上的操作这一事实)，所以，既可以说对象是类型的实例，也可以说对象是类的实例，类型和类在与对象的关系上是相同的。不过，类型欲刻划一组对象及其上的操作，必须借助于类，因为类是达到这种目的的唯一设施。由此可见，类型是以类为基础的，是通过类来定义的，这体现了二者的联系。
B: 区别
l 作用不同
类是程序的构造单位，是描述一组对象及其上操作的唯一语言成分，故其作用主要是具体描述这组对象，提供运行时创建这些对象的“模板”。例如，基于类间的继承关系的派生类定义设施就反映了类在描述对象方面的作用。

类型则是标志变量或表达式取值范围的一种语言成分，其作用主要是对这些变量或表达式运行时的取值进行约束。例如，对赋值语句左部的变量和右部的表达式的类型匹配检查就反映了类型的约束作用。

l 与对象联系的紧密程序不同

类描述对象的具体形式和其上可施行的具体操作，且强调所描述的一组对象的共性，因而，与具体对象联系较密切，而与对象集的大小则联系较少。

类型强调所描述的一组对象的范围和可施行操作的范围，与对象集的大小联系较密切，而与其中具体对象则联系较少。

l 并不是所有类都可直接作为类型使用
类是类型的基础，类型靠类来定义，有些类可直接作为类型来使用，在这种意义下，我们也可称这些类是类型。
但是，也有一些类不能直接作为类型来使用，这是因为，从类型的约束作用来看，类型强调所刻划的对象的确定性，即对象范围的确定性。因此，只有所描述的对象的范围确定的类才可直接用作类型。

‘肆’ JAVA反射机制的Class

众所周知Java有个Object 类，是所有Java 类的继承根源，其内声明了数个应该在所有Java 类中被改写的方法：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象。
Class 类十分特殊。它和一般类一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types（boolean, byte, char, short, int, long, float, double）以及关键词void。当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class 对象。如果您想借由“修改Java标准库源码”来观察Class 对象的实际生成时机（例如在Class的constructor内添加一个println()），这样是行不通的！因为Class并没有public constructor。
Class是Reflection故事起源。针对任何您想探勘的类，唯有先为它产生一个Class 对象，接下来才能经由后者唤起为数十多个的Reflection APIs。这些APIs将在稍后的探险活动中一一亮相。
public final
class Class<T> implements Serializable,
java.lang.reflect.GenericDeclaration,
java.lang.reflect.Type,
java.lang.reflect.AnnotatedElement {
private Class() {}
public String toString() {
return ( isInterface() ? interface :
(isPrimitive() ? : class ))
+ getName();
}
...
图1：Class class片段。注意它的private Class() {}，意指不允许任何人经由编程方式产生Class object。是的，其object 只能由JVM 产生。

‘伍’ java中反射的三种方法是

第一种：通过forName()方法；

第二种：类.class；

第三种：对象.getClass()。

举例如下：

package
test;

public class Demo{

public static void
main(){

Class<?> c1 = null;

Class<?> c2 =
null;

Class<?> c3 =
null;

//三种反射用实例化方式

try{

//最常用的一种形式

c1 =
Class.forName("test.X");

}catch(ClassNotFoundException
e){

e.printStackTrace();

}

//通过Object类中的方法实例化

c2
= new X().getClass();

//通过类.class实例化

c3 =
X.class;

System.out.println("类名：" + c1.getName());
//得到类名

System.out.println("类名：" + c2.getName());
//得到类名

System.out.println("类名：" + c3.getName());
//得到类名

}

}

‘陆’ java反射机制详解

反射就是把Java的各种成分映射成相应的Java类。
Class类的构造方法是private，由JVM创建。
反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。（来自Sun）
JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。
反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类"Class",无法直接new CLass()，其对象是内存里的一份字节码.
Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
基本的 Java类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。Class 没有公共构造方法。
Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
Person p1 = new Person();
//下面的这三种方式都可以得到字节码
CLass c1 = Date.class();
p1.getClass();
//若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来
Class.forName("java.lang.String");

Class.forName()字节码已经加载到java虚拟机中，去得到字节码；java虚拟机中还没有生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中。
另外，大家可以关注微信公众号Java技术栈回复：JVM，获取我整理的系列JVM教程，都是干货。
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
import java.lang.reflect.*;

public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName("java.util.Stack");

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
}
catch (Throwable e){
System.err.println(e);
}
}
}

public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。
以下示例使用 Class 对象来显示对象的类名：
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}

还可以使用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：
System.out.println("The name of class Foo is: "+Foo.class.getName());

在没有对象实例的时候，主要有两种办法。
//获得类类型的两种方式
Class cls1 = Role.class;
Class cls2 = Class.forName("yui.Role");

注意第二种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了，利用Class的newInstance方法相当于调用类的默认的构造器。
Object o = cls1.newInstance();
//创建一个实例
//Object o1 = new Role(); //与上面的方法等价

‘柒’ Java中为什么反射机制中的属性的类型是Class类型的 方式机制中那么哪些东西是Class类型的呢

什么意思呢? 属性类型是Class类型的? 没懂..
Class是个类, 一个可以实例化任意一个类的类, 在反射里面经常用到.

‘捌’ java怎么样使用class反射！！！

这是我自己写的一个类,用java反射写的。有多个功能。如数据拷贝等。具体请看代码注释(超过10000字不让发。)你可以参考一下完整代码可以到我空间查看 public class BaseClass {

/**
* @描述： 执行指定对象的指定方法(该方法更适合于执行无参的构造方法和有参的方法)
* @param obj 需要执行的对象的实例(如果对象的实例不存在即指定 obj == null,则系统会新创建一个实例);
* @param className 需要执行的对象的实例(如果对象的实例不存在即指定 obj == null,则系统会新创建一个实例);
* @param className 对象的名称(需要添加包名如 com.bin.test.testBean其中com.bin.test为包名testBean为方法名)
* @param methodName 需要执行对象中的方法名称(可通过displayAllMethod(T t))来查看该对象有哪些方法 如：Test对象中有方法
* setAge(int age);则methodName应写为[setAge]
* @param methodParmeterNames 需要执行的方法的参数名 基本类型可直接用int,char等来表示,但是如果是其他类型如List则必需写成java.util.List具体参数类型可通过displayAllMethod(T t)
* 方法来查看该对象的所有方法及需要的参数类型) 同时请注意：methodParmeterNames必须和methodParmeterValues配对出现且数量必须一样;如methodParmeterNames
* 为null则参数methodParmeterValues也必须为null(即无参方法),如methodParmeterNames长度为1，则methodParmeterValues的长度也必须为1
* @param methodParmeterValues 需要执行的方法的参数值 请注意：methodParmeterNames必须和methodParmeterValues配对出现且数量必须一样;如methodParmeterNames
* 为null则参数methodParmeterValues也必须为null(即无参方法),如methodParmeterNames长度为1，则methodParmeterValues的长度也必须为1
* @return
*/
public Object executeMethod(Object obj,String className,String methodName,String[]methodParmeterNames,Object[] methodParmeterValues){
return executeMethod(obj, className, null, null, methodName, methodParmeterNames, methodParmeterValues);
}
/**
* @描述： 执行指定对象的指定方法(该方法更适合于执行无参的构造方法和无参的方法)
* @param obj 需要执行的对象的实例(如果对象的实例不存在即指定 obj == null,则系统会新创建一个实例);
* @param className 对象的名称(需要添加包名如 com.bin.test.testBean其中com.bin.test为包名testBean为方法名)
* @param methodName 需要执行对象中的方法名称(可通过displayAllMethod(T t))来查看该对象有哪些方法 如：Test对象中有方法
* setAge(int age);则methodName应写为[setAge]
* @return
*/
public Object executeMethod(Object obj,String className,String methodName){
return executeMethod(obj, className, null, null, methodName, null, null);
}
/**
* @描述： 执行指定对象的指定方法
* @param obj 需要执行的对象的实例(如果对象的实例不存在即指定 obj == null,则系统会新创建一个实例);
* @param className 对象的名称(需要添加包名如 com.bin.test.testBean其中com.bin.test为包名testBean为方法名)
* @param ConstructorParameterNames 构造方法的参数名 基本类型可直接用int,char等来表示,但是如果是其他类型如List则必需写成java.util.List具体参数类型可通过displayAllConstructor(T t)
* 方法来查看该对象的所有构造方法及需要的参数类型) 同时请注意：ConstructorParameterNames必须和ConstructorParameterValues配对出现且数量必须一样;如ConstructorParameterNames
* 为null则参数ConstructorParameterValues也必须为null(即无参构造方法),如ConstructorParameterNames长度为1，则ConstructorParameterValues的长度也必须为1
* @param ConstructorParameterValues 构造方法的参数值 请注意：ConstructorParameterNames必须和ConstructorParameterValues配对出现且数量必须一样;如ConstructorParameterNames
* 为null则参数ConstructorParameterValues也必须为null(即无参构造方法),如ConstructorParameterNames长度为1，则ConstructorParameterValues的长度也必须为1
* @param methodName 需要执行对象中的方法名称(可通过displayAllMethod(T t))来查看该对象有哪些方法 如：Test对象中有方法
* setAge(int age);则methodName应写为[setAge]
* @param methodParmeterNames 需要执行的方法的参数名 基本类型可直接用int,char等来表示,但是如果是其他类型如List则必需写成java.util.List具体参数类型可通过displayAllMethod(T t)
* 方法来查看该对象的所有方法及需要的参数类型) 同时请注意：methodParmeterNames必须和methodParmeterValues配对出现且数量必须一样;如methodParmeterNames
* 为null则参数methodParmeterValues也必须为null(即无参方法),如methodParmeterNames长度为1，则methodParmeterValues的长度也必须为1
* @param methodParmeterValues 需要执行的方法的参数值 请注意：methodParmeterNames必须和methodParmeterValues配对出现且数量必须一样;如methodParmeterNames
* 为null则参数methodParmeterValues也必须为null(即无参方法),如methodParmeterNames长度为1，则methodParmeterValues的长度也必须为1
* @return
*/
public Object executeMethod(Object obj,String className,String[]ConstructorParameterNames,Object[] ConstructorParameterValues,String methodName,String[]methodParmeterNames,Object[] methodParmeterValues) {
try {
//如果用户未指定一个对象的实例则方法会自动为用户创建一个对象的实例
if(obj==null)obj = getInstance(className, ConstructorParameterNames, ConstructorParameterValues);//创建一个实例
//将用户传递进入的参数转换为相应的class参数类型
Class[] methodParName = getMethodClass(methodParmeterNames);
//从指定对象实例中获取指定方法
Method method = obj.getClass().getMethod(methodName, methodParName);
//执行该实例的某个方法
return method.invoke(obj, methodParmeterValues);
} catch (SecurityException e) {
e.printStackTrace();
return null;
} catch (NoSuchMethodException e) {
e.printStackTrace();
return null;
} catch (IllegalArgumentException e) {
e.printStackTrace();
return null;
} catch (IllegalAccessException e) {
e.printStackTrace();
return null;
} catch (InvocationTargetException e) {
e.printStackTrace();
return null;
}

}

/**
* @描述： 创建对象的一个新实例
* @param className 对象的名称(需要添加包名如 com.bin.test.testBean其中com.bin.test为包名testBean为方法名)
* @return Object对象的新实例(创建失败返回null)
*/
public Object getInstance(String className){
return getInstance(className, null, null);
}

/**
* @描述： 创建对象的一个新实例
* @param className 对象的名称(需要添加包名如 com.bin.test.testBean其中com.bin.test为包名testBean为方法名)
* @param parameterNames 构造方法的参数名 parameterNames必须和parameterValues配对出现且数量必须一样;如parameterNames
* 为null则参数parameterValues也必须为null(即无参构造方法),如parameterNames长度为1，则parameterValues的长度也必须为1
* @param parameterValues 构造方法的参数值 parameterValues必须和parameterNames配对出现且数量必须一样;如parameterValues
* 为null则参数parameterNames也必须为null(即无参构造方法),如parameterValues长度为1，则parameterNames的长度也必须为1
* @return Object对象的新实例(创建失败返回null)
*/
public Object getInstance(String className,String[]parameterNames,Object[] parameterValues){
//加载class
try {
Class cls = Class.forName(className);
//将用户传递进入的参数转换为相应的class参数类型
Class[] classPar = getMethodClass(parameterNames);//获取构造方法对应的参数类型
//获取指定对象的构造方法
Constructor cst = cls.getConstructor(classPar);
Object obj = null;
//根据参数类型创建一个对象的实例
if(classPar==null||classPar.length==0){
obj = cst.newInstance(null);
}else{
obj = cst.newInstance(parameterValues);
}
return obj;
} catch (ClassNotFoundException e) {
e.printStackTrace();
return null;
} catch (SecurityException e) {
e.printStackTrace();
return null;
} catch (NoSuchMethodException e) {
e.printStackTrace();
return null;
} catch (IllegalArgumentException e) {
e.printStackTrace();
return null;
} catch (InstantiationException e) {
e.printStackTrace();
return null;
} catch (IllegalAccessException e) {
e.printStackTrace();
return null;
} catch (InvocationTargetException e) {
e.printStackTrace();
return null;
}

}

/**
* @描述：将一个bean中的字段内容 复制到另一个bean上(注意：前提条件为名称相同并且类型相同)
* @param <T>
* @param <S>
* @param t 目标对象(注意：目标对象中必须与源对象中存在名称相同，且类型相同的字段)
* @param s 数据源对象(注意：源对象中必须与目标对象中存在名称相同，且类型相同的字段)
* @return
*/
public <T,S> T (T t, S s){
try {
setValueToBean(t,s);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return t;
}

/**
* @描述：查询该对象的所有构造方法(包含私有方法)
* @param <T>
* @param t
*/
public <T>void displayAllConstructor(T t){
for(int i=0;i<t.getClass().getDeclaredConstructors().length;i++){
System.out.println(t.getClass().getDeclaredConstructors()[i]);
}
}
/**
* @描述：查询该对象的所有方法(包含私有方法)
* @param <T>
* @param t
*/
public <T> void displayAllMethod(T t){
for(int i=0;i<t.getClass().getDeclaredMethods().length;i++){
System.out.println(t.getClass().getDeclaredMethods()[i]);
}
}
/**
* @描述：查询该对象的所有字段(包含私有方法)
* @param <T>
* @param t
*/
public <T> void displayAllField(T t){
for(int i=0;i<t.getClass().getDeclaredFields().length;i++){
System.out.println(t.getClass().getDeclaredFields()[i]);
}
}
//后面的代码删除了。。因过长