❶ 在JAVA中，怎么利用反射获取一个方法
java的反射用法：(异常请自行处理)
①找到类：Class cl = Class.forName("java.util.Date");
②创建对象(要求这个类中含有空参数的构造方法)：Object obj = cl.newInstence();
③根据名称和参数找方法：Method method1 = cl.getMethod("getTime");//如果没有参数不用写第二个参数如果有参数的如：Method method2 = cl.getMethod("setTime",long.class);
④在某个对象上面执行方法，Object result = method1.invoke(obj);//如果有参数的Object result = method2.invoke(obj,21317362721);
执行的方如果有返回值，将返回值返回，否则返回null
❷ 通过反射动态执行对象的方法的步骤是什么
这个属于java反射机制范围：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这 种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。主要功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对 象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法，生成动态代理。
动态执行当前类或其父类的方法，支持私有方法。
具体实现方法如下：
publicstaticvoidmain(String[]args)throwsException{
Classc=Dynamic.class;//得到对象
Method[]methods=c.getDeclaredMethods();//得到方法
for(Methodmethod:methods){
System.out.print(method.getName());//打印参数名Class[]parameterTypes=method.getParameterTypes();
for(inti=0;i<parameterTypes.length;i++){
StringnameString=parameterTypes[i].getName();
System.out.print("parameterType:"+nameString);//打印方法参数类型}
System.out.print("ReturnType:"+method.getReturnType());
System.out.println();
}
Objectobj=c.newInstance();//获取到方法对象,假设方法的参数是一个int,String,method名为getAge
MethodsAge=c.getMethod("getAge",newClass[]{int.class,String.class});
//获得参数Object
Object[]arguments=newObject[]{newInteger(23),newString("abc")};
//执行方法
Strings=(String)sAge.invoke(obj,arguments);
System.out.print(s);
}
publicStringgetAge(intage,Stringname){
returnname+":"+age;
}
}
❸ 为什么用newInstance方法去创建对象是一种利用反射创建对象的方法
首先总结下，创建对象的3中方式：
使用new的方式，最为常见。
使用对象的clone()方法。
使用反射机制的newInstance()方法。
举个简单的例子：
packagecom.java;
publicclassDemo
{
/**
*通过两种方式创建对象，以做对比。
*@paramargs
*@throwsClassNotFoundException
*@throwsInstantiationException
*@throwsIllegalAccessException
*/
publicstaticvoidmain(String[]args)throwsClassNotFoundException,
InstantiationException,IllegalAccessException
{
//我们认为这种方方式，Demo类和Basic类是耦合的，
//编译Demo类时，Basic类必须存在,拓展性不强。
Basicbasic0=newBasic();
//很明显这种方式，在编译Demo类时，并不需要
//Basic类的存在，只要在运行Demo类时，存在即可，
//所以我们认为Demo类和Basic是松耦合的，
//为后期的拓展提供了空间，好处显而易见。这么说，如果没有
//反射机制，就没有struts、spring、hibernate等等这些web框架。
Classclazz=Class.forName("com.java.Basic");
Basicbasic1=(Basic)clazz.newInstance();
}
}
classBasic
{
}
好好体会下，反射带来的便利。
❹ 关于用java反射调用一个类里面的方法并执行
Java中要用到反射，首先就必须要获取到对应的class对象，在Java中有三种方法获取类对应的class对象。
1、通过类的.class属性
2、通过类实例的getClass()方法获取
3、通过Class.forName(String className)方法获取
现在比如在package下有个类Calculator
publicclassCalculator{
publicdoubleadd(doublescore1,doublescore2){
returnscore1+score2;
}
publicvoidprint(){
System.out.println("OK");
}
publicstaticdoublemul(doublescore1,doublescore2){
returnscore1*score2;
}
}publicclassCalculatorTest{
publicstaticvoidmain(String[]args)throwsException{
//通过类的.class属性获取
Class<Calculator>clz=Calculator.class;
//或者通过类的完整路径获取,这个方法由于不能确定传入的路径是否正确,这个方法会抛ClassNotFoundException
// Class<Calculator>clz=Class.forName("test.Calculator");
//或者new一个实例,然后通过实例的getClass()方法获取
// Calculators=newCalculator();
// Class<Calculator>clz=s.getClass();
//1.获取类中带有方法签名的mul方法,getMethod第一个参数为方法名,第二个参数为mul的参数类型数组
Methodmethod=clz.getMethod("mul",newClass[]{double.class,double.class});
//invoke方法的第一个参数是被调用的对象,这里是静态方法故为null,第二个参数为给将被调用的方法传入的参数
Objectresult=method.invoke(null,newObject[]{2.0,2.5});
//如果方法mul是私有的private方法,按照上面的方法去调用则会产生异常NoSuchMethodException,这时必须改变其访问属性
//method.setAccessible(true);//私有的方法通过发射可以修改其访问权限
System.out.println(result);//结果为5.0
//2.获取类中的非静态方法
Methodmethod_2=clz.getMethod("add",newClass[]{double.class,double.class});
//这是实例方法必须在一个对象上执行
Objectresult_2=method_2.invoke(newCalculator(),newObject[]{2.0,2.5});
System.out.println(result_2);//4.5
//3.获取没有方法签名的方法print
Methodmethod_3=clz.getMethod("print",newClass[]{});
Objectresult_3=method_3.invoke(newCalculator(),null);//result_3为null,该方法不返回结果
}
}
❺ 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(); //与上面的方法等价
❻ 如何利用反射创建一个对象List
java中反射的三种方法： 1. 通过Object类的getClass方法来获取 java.lang.Object中定义有getClass方法：public final Class getClass() 所有Java对象都具备这个方法，该方法用于返回调用该方法的对象的所属类关联的Class对象，
❼ java中的反射怎么用
首先应该说 反射机制提供的功能是很强大的 但是客观性和维护性很差
一般反射用在 构造框架 以及工具开发等等
但是实际开发软件运用的并不多
下面是一个简单的例子
package com.wqx.test4;
public class Test {
public void sayhello(String name)
{
System.out.println("hello:"+name);
}
public static void main(String[] args) {
try {
//把test 这个类载入内存
Class c=Class.forName("com.wqx.test4.Test");
//创建这个类的实例
Object obj=c.newInstance();
//通过class来取得这个方法对象 并且声明 这个类的参数类型
java.lang.reflect.Method method=c.getMethod("sayhello", Class.forName("java.lang.String"));
//invoke 来执行方法对象 记得参数类型要跟这里的参数匹配
method.invoke(obj, "wqx");
} catch (Exception e) {
// TODO: handle exception
}
}
}
❽ 如何利用java的反射机制动态创建对象
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。当然反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。
Java反射机制主要提供下面几种用途：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法
以下，我们就以动态创建对象为例，通过代码来解释一下反射：
public class ReflectionTest {
public static void main(String[] args) throws Exception {
// 建立学生对象
Student student = new Student();
// 为学生对象赋值
student.setStuName("Wanggc");
student.setStuAge(24);
// 建立拷贝目标对象
Student destStudent = (Student) Bean(student);
// 输出拷贝结果
System.out.println(destStudent.getStuName() + ":"
+ destStudent.getStuAge());
}
/**
* 拷贝学生对象信息。
*
* @param from
拷贝源对象
* @param dest
拷贝目标对象
* @throws Exception
例外
*/
private static Object Bean(Object from) throws Exception {
// 取得拷贝源对象的Class对象
Class<?> fromClass = from.getClass();
// 取得拷贝源对象的属性列表
Field[] fromFields = fromClass.getDeclaredFields();
// 取得拷贝目标对象的Class对象
Object ints = fromClass.newInstance();
for (Field fromField : fromFields) {
// 设置属性的可访问性
fromField.setAccessible(true);
// 将拷贝源对象的属性的值赋给拷贝目标对象相应的属性
fromField.set(ints, fromField.get(from));
}
return ints;
}
}
❾ mybatis的反射工具类—MetaObject（反射对象类）
MeatObject是Mybatis的工具类，通过MetaObject获取和设置对象的属性值。
返回结果：
基本的pojo对象：
MetaObject提供了一个工具类：
当调用 SystemMetaObject 获取 MetaObject 对象时，每次均 new DefaultReflectorFactory() 了一个反射工厂类。
继续查看：
这个类并没有做很复杂的操作，就是获取object的type类型，且存储到Map中。当同一个object调用 forObject() 时，后续调用可以在缓存中获取反射对象。
但注意： SystemMetaObject 方法因为每次均new了一个新的 DefaultReflectorFactory 工厂。若每次在方法中调用 SystemMetaObject.forObject 获取 MetaObject 对象。同一个对象可能不会走缓存。
推荐做法： 将 DefaultReflectorFactory 声明为静态变量：
在创建 MetaObject 对象的时候，就会将传入的Object对象的所有反射对象都缓存起来。后续调用 metaObject.setValue 等方法时，直接在缓存中获取到反射对象，然后执行反射操作。
创建MetaObject对象时，选择不同的Wrapper进行包装。
以普通的pojo为例，创建 BeanWrapper 对象，在 forClass 方法中会遍历object的所有方法。获取反射对象。
到此处：
到达此处，判断 缓存 中是否存在某对象的解析结果：
注意： MetaObject.forObject 会将object结果缓存起来，后续在使用MetaObject.forObject创建对象时，直接在缓存中获取。
若没有存在，则调用 new Reflector(type); 去创建cache对象。
总方法：
2. 删除方法的前缀，获取属性名：
3. key为属性名，value是集合：
4. 将局部变量放入到属性集合中：
5. 放入到属性变量中
设置分词器：
https://www.cnblogs.com/javadeveloper/archive/2004/01/13/13151682.html
❿ 如何通过反射来创建对象
Class clazz = Class.forName("com.fanshe.Person");
//当然如果你需要将全部的字段都访问的话，那么就需要getdecaredFields()方法
Field field = clazz.getDeclaredField("age");//该方法会调用该类中所有的字段
field.setAccessible(true);//暴力访问，取消age的私有权限。让对象可以访问
Object obj = clazz.newInstance();
field.set(obj, 32);//设置对象中，私有变量的值
int age = field.getInt(obj);//获取该字段的值，必须与对象结合起来，不然的话，会出现错误