java反射技术

1. java中反射是什么

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

Java反射的功能是在运行时判断任意一个对象所属的类，在运行时构造任意一个类的对象，在运行时判断任意一个类所具有的成员变量和方法，在运行时调用任意一个对象的方法，生成动态代理。

(1)java反射技术扩展阅读：

JAVA中反射实例：

1、Class superClass=clazz.getSuperclass();//获取父类。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//获取实现接口。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//构造方法。

System.out.println("getConstructors:"+cons.length)。

参考资料来源：网络： JAVA反射机制

2. 什么是反射什么Java反射

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

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

3. 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());
//得到类名

}

}

4. 什么是JAVA的反射机制有什么作用

现在学习Java的平台有很多，B站或者是腾讯课堂都是可以的，我们在B站分享了很多经典的Java视频教程，都是开源的，你可以去看看。

5. 哪些项目中用到了Java反射机制

什么是反射？将类的每个组件封装到另一个对象中的过程称为反射。其中，组件表示我们类的成员变量(Field)、构造方法(Constructor)和成员方法(Method)。反射使您可以在程序运行期间操作类对象，从而提高程序的灵活性。解耦提高了程序的可扩展性，提高了代码重用率，便于外部调用。任何类别只要知道类别名称，就可以知道该类别的所有属性和方法。

反射像镜子一样，让开发者知道这个类中有哪些成员。大多数人想知道Java有包，为什么会有反射。破坏封装性。通过允许外部访问个人变量，使类不太安全。就我个人而言，反射机制实际上是上帝的模型。如果方法的调用是Java正确的打开方式，那么反射机制就是上帝偷偷打开的后门。只要有相应的class存在，什么都可以调用。那么，上帝为什么要打开这个后门呢？这包括静态和动态概念。

6. 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(); //与上面的方法等价

7. java的反射技术有什么用

一、反射的概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

以上的总结就是什么是反射
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

希望对您有所帮助！~

8. java反射的作用。

1. Java反射包reflection提供对Class，Method，field，constructor1 等信息的封装类型。
2. 通过这些api可以轻易获得一个类的各种信息并且可以进行实例化，方法调用等。
类中的private参数可以通过setaccessible方法强制获取。
3. 反射的作用可谓是博大精深，JDK动态代理生成代理类的字节码后，首先把这个类通过defineclass定义成一个类，然后用class.for(name)会把该类加载到jvm，之后我们就可以通过，A.class.GetMethod()获取其方法，然后通过invoke调用其方法，在调用这个方法时，实际上会通过被代理类的引用再去调用原方法。

9. Java的反射机制是什么，如何实现

Java中的反射机制，通俗点解释就是能够在程序运行中动态获取到内存中任一对象的信息，这些信息包括对象所属类、类中的方法和属性、以及它们的访问控制域和返回值类型等等，还可以通过反射动态调用对象中的方法，而不管该方法的访问域是私有或是公开，包括构造方法，还能实现动态代理等。总之，反射能够破坏掉JAVA类本身的封装性，进而获取其私有的或公开的信息，也就能突破封装进而调用私有的或公开的方法。
实现的话就是通过反射接口，JAVA把反射相关的类接口都封装在了java.lang.reflect这个包中，你可以研究下这个包中的类，对于类的每一个属性，如变量、方法，构造方法，这个包中都就与之相对应的类，通过这个类就可以操作这个属性了。
java反射很强大，但也很危险，在实际开发中应少用或不用，在必要用之时，往往也能解决你遇到的问题。

10. java中的反射机制是什么，有什么作用啊

Method类中的方法的使用（含代码和注释）：

getMethods()获得本类及父类中的public权限修饰**符方法
getDeclaredMethods()专门获得调用该方法的对象的本类中的所有方法包括private权限修饰符**的方法
getDeclaredMethod(Stringname,class<?>...parameterTypes)
第一个参数：方法的名称
第二个参数：可变长度，写你要查找的那个方法的参数类型列表.class
getParameterCount()得到方法的参数个数123456
packageLessonForReflection03;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;abstractclassCard{
privatevoidcreatRandomNumbers(intcount)//private关键字
{

}

publicvoidgetFullCardsNumbers(String[]random,Stringpre_numbers)
{

}

publicstaticvoidgetUserInfor()
{

}

(Stringtel);

(intsal1,intsal2),ArithmeticException;}publicclassMethodInforGetter{

publicstaticvoidmain(String[]args)
{
Class<?>c1=Card.class;

System.out.println("-------------------------");

Method[]m1=c1.getMethods();//getMethods()获得本类及父类中的public方法！
for(Methodm:m1)
{
System.out.println(m);
}

System.out.println("-------------------------");

Method[]m2=c1.getDeclaredMethods();//getDeclaredMethods()专门获得本类中的所有方法包括private！
for(Methodm:m2)
{
System.out.println(m);
}

System.out.println("-------------------------");

/*
*getDeclaredMethod(Stringname,class<?>...parameterTypes)
*第一个参数：方法的名称
*第二个参数：可变长度，写你要查找的那个方法的参数类型列表
*
*getParameterCount()得到方法的参数个数
*/

try
{
Methodm3=c1.getDeclaredMethod("getUserInfor");
System.out.println(m3);

//getParameterCount()方法,获得方法参数个数
System.out.println(m3.getParameterCount());
System.out.println(Modifier.toString(m3.getModifiers()));//获得方法修饰符
System.out.println(m3.getReturnType());

System.out.println("-------------------------");

Methodm4=c1.getDeclaredMethod("getUserInfor",int.class,int.class);

//getExceptionTypes()可以获得初始化当前Method对象的给Class对象初始化的那个类的那个指定方法抛出的异常类型
Class<?>[]exception=m4.getExceptionTypes();
for(Class<?>e:exception)
{
System.out.println(e);
}

}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}576777879808182838485868788

Constructor类中的方法的使用www.xiaoyuani.com（含代码和注释）：

java.lang.reflect.Constructor:
Constructor[]getConstructor()获得本类里的public权限修饰符构造函数，不能获取父类的！
Constructor[]getDeclaredConstructor()获得本类中的所以构造函数！
Constructor<T>getConstructor(Class...parameterType)用参数决定获得本类中的某个的构造方法,只能获得public的
Constructor<T>getDeclaredConstructor(Class...parameterType)用参数决定获得本类中的某个构造方法
附：
JDK8.0之后新增的类：
Executable：
它是Method和Constructor的父类
常用方法：
getParameter()获得类中方法参数
getExceptionTypes()获得类中某个方法抛出异常类型
getMoidfiers()获得方法权限修饰符
Parameter:
封装并代表了参数实例123456789101112131415
packageLessonForReflection03;importjava.lang.reflect.Constructor;importjava.lang.reflect.Modifier;importjava.lang.reflect.Parameter;/*
*java.lang.reflect.Constructor
*
*Constructor[]getConstructor();获得本类里的public权限修饰符构造函数，不能获取父类的
*Constructor[]getDeclaredConstructor();得本类里的全部构造
*
*Constructor<T>getConstructor(Class...parameterType);用参数决定获得哪个构造方法
*Constructor<T>getDeclaredConstructor(Class...parameterType);
*
*/{
publicstaticvoidmain(String[]args)
{
System.out.println("获得Cricle本类里的public权限修饰符构造函数，不能获取父类的Constructor[]getConstructor()");
System.out.println("子类继承不了父类中的构造方法和private");
//Constructor[]getConstructor()获得Cricle本类里的public权限修饰符构造函数，不能获取父类的
//子类继承不了父类中的构造方法和private
Class<Circle>c1=Circle.class;
Constructor<?>[]cons1=c1.getConstructors();
for(Constructor<?>cons:cons1)
{
System.out.println(cons);
//System.out.println(cons.getName());
}

System.out.println("-----------------------");

System.out.println("方法获得本类中的所有构造函数getDeclaredConstructor()");
Constructor<?>[]cons2=c1.getDeclaredConstructors();
for(Constructor<?>cons:cons2)
{
System.out.println(cons);
}

System.out.println("-----------------------");

try
{
System.out.println("方法用参数指定获得本类！构造方法,只能获取public的Constructor<T>getConstructor(Class...parameterType)");
Constructor<?>cons3=c1.getConstructor(int.class);
System.out.println(Modifier.toString(cons3.getModifiers()));
System.out.println(cons3);

System.out.println("-----------------------");

System.out.println("方法用参数指定获得本类！构造方法任何权限修饰符的都可以获得Constructor<T>getDeclaredConstructor(Class...parameterType)");
Constructor<?>cons4=c1.getDeclaredConstructor(String.class);
System.out.println(cons4);

System.out.println("-----------------------");

/*
*JDK8.0之后新增的类
*Executable：
*是Method和Constructor的父类
*方法：
*getParameter();
*getExceptionTypes();
*getModifiers();
*getTypeParameters();
*
*Parameter:
*封装并代表了参数实例
*/
System.out.println("获取类中方法的参数getParameters()");
Constructor<?>cons5=c1.getDeclaredConstructor(int.class,String.class);
Parameter[]p1=cons5.getParameters();
for(Parameterp:p1)
{
System.out.println(p);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}

}}5767778798081828384858687

代码中提到的Circle类和Shape类二者为继承关系：

packageLessonForReflection03;publicclassCircleextendsShape{
privateintr;
privateStringcolor;

publicCircle(intr,Stringcolor)
{
super();
this.r=r;
this.color=color;
}

publicCircle(intr)
{
super();
this.r=r;
}

protectedCircle(Stringcolor)
{
super();
this.color=color;
}

Circle()
{
super();
}}
packageLessonForReflection03;publicclassShape{
privateintper;

publicShape(intper)
{
super();
this.per=per;
}

publicShape()
{
super();
}}1234567891011121314151617

部分文字来源于：
咕嘟咖啡杨海滨老师 — 《java编程语言高级特性》
轻量化研习Java相关技术倡导者
“爱码学院”联合创始人自适应教学理念提出者践行者；多年开发及项目管理经历；出版《JavaEE企业级应用与开发》一书；10余年高校项目实践毕设指导经验；企业软培经验丰富