关键词：
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());
//得到类名
参考技术A 反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。
反射的好处：大大的增强了程序的扩展性。
反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。
获取这个Class对象，有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。
3：使用的Class类中的方法，静态的forName方法。
指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。
// 1. 根据给定的类名来获得 用于类加载
String classname = "cn.itcast.reflect.Person";// 来自配置文件
Class clazz = Class.forName(classname);// 此对象代表Person.class
// 2. 如果拿到了对象，不知道是什么类型 用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass();// 获得对象具体的类型
// 3. 如果是明确地获得某个类的Class对象 主要用于传参
Class clazz2 = Person.class;
反射的用法：
1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：
Class.forName(classname) 用于做类加载
obj.getClass() 用于获得对象的类型
类名.class 用于获得指定的类型，传参用
2)、反射类的成员方法：
Class clazz = Person.class;
Method method = clazz.getMethod(methodName, new Class[]paramClazz1, paramClazz2);
method.invoke();
3)、反射类的构造函数：
Constructor con = clazz.getConstructor(new Class[]paramClazz1, paramClazz2,...)
con.newInstance(params...)
4)、反射类的属性：
Field field = clazz.getField(fieldName);
field.setAccessible(true);
field.setObject(value);
获取了字节码文件对象后，最终都需要创建指定类的对象：
创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：
1，调用空参数的构造函数：使用了Class类中的newInstance()方法。
2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。
综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。
------------------------------------------------------
// 如何生成获取到字节码文件对象的实例对象。
Class clazz = Class.forName("cn.itcast.bean.Person");//类加载
// 直接获得指定的类型
clazz = Person.class;
// 根据对象获得类型
Object obj = new Person("zhangsan", 19);
clazz = obj.getClass();
Object obj = clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();
public static void method_2() throws Exception
Class clazz = Class.forName("cn.itcast.bean.Person");
//既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
//获取一个带参数的构造器。
Constructor constructor = clazz.getConstructor(String.class,int.class);
//想要对对象进行初始化，使用构造器的方法newInstance();
Object obj = constructor.newInstance("zhagnsan",30);
//获取所有构造器。
Constructor[] constructors = clazz.getConstructors();//只包含公共的
constructors = clazz.getDeclaredConstructors();//包含私有的
for(Constructor con : constructors)
System.out.println(con);
------------------------------------------------------
反射指定类中的方法：
//获取类中所有的方法。
public static void method_1() throws Exception
Class clazz = Class.forName("cn.itcast.bean.Person");
Method[] methods = clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。
methods = clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。
for(Method method : methods)
System.out.println(method);
//获取指定方法；
public static void method_2() throws Exception
Class clazz = Class.forName("cn.itcast.bean.Person");
//获取指定名称的方法。
Method method = clazz.getMethod("show", int.class,String.class);
//想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。
Object obj = clazz.newInstance();
method.invoke(obj, 39,"hehehe");//执行一个方法
//想要运行私有方法。
public static void method_3() throws Exception
Class clazz = Class.forName("cn.itcast.bean.Person");
//想要获取私有方法。必须用getDeclearMethod();
Method method = clazz.getDeclaredMethod("method", null);
// 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。
method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。
//反射静态方法。
public static void method_4() throws Exception
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("function",null);
method.invoke(null,null);
参考技术B java中反射的三种方法：
1. 通过Object类的getClass方法来获取
java.lang.Object中定义有getClass方法：public final Class getClass()
所有Java对象都具备这个方法，该方法用于返回调用该方法的对象的所属类关联的Class对象，例如：
Date date1 = new Date();
Date date2 = new Date();
Class c1 = date1.getClass();
Class c2 = date2.getClass();
System.out.println(c1.getName());
// java.util.Date
System.out.println(c1 == c2);
// true
上面的代码中，调用Date对象date1的getClass方法将返回用于封装Date类信息的Class对象。
这里调用了Class类的getName方法：public String getName()，这个方法的含义很直观，即返回所封装的类的名称。
需要注意的是，代码中的date1和date2的getClass方法返回了相同的Class对象（c1==c2的值为true）。这是因为，对于相同的类，JVM只会载入一次，而与该类对应的Class对象也只会存在一个，无论该类实例化了多少对象。
另外，需要强调的是，当一个对象被其父类的引用或其实现的接口类型的引用所指向时，getClass方法返回的是与对象实际所属类关联的Class对象。例如：
List list = new ArrayList();
System.out.println(list.getClass().getName()); // java.util.ArrayList
上面的代码中，语句list.getClass()方法返回的是list所指向对象实际所属类java.util.ArrayList对应的 Class对象而并未java.util.List所对应的Class对象。有些时候可以通过这个方法了解一个对象的运行时类型，例如：
HashSet set = new HashSet();
Iterator it = set.iterator();
System.out.println(it.getClass().getName()); //java.util.HashMap$KeyIterator
从代码可以看出，HashSet的iterator方法返回的是实现了Iterator接口的HashMap内部类（KeyIterator）对象。
因为抽象类和接口不可能实例化对象，因此不能通过Object的getClass方法获得与抽象类和接口关联的Class对象。
2. 使用.class的方式
使用类名加“.class”的方式即会返回与该类对应的Class对象。例如：
Class clazz = String.class;
System.out.println(clazz.getName()); // java.lang.String
这个方法可以直接获得与指定类关联的Class对象，而并不需要有该类的对象存在。
3. 使用Class.forName方法
Class有一个著名的static方法forName：public static Class forName(String className) throws ClassNotFoundException
该方法可以根据字符串参数所指定的类名获取与该类关联的Class对象。如果该类还没有被装入，该方法会将该类装入JVM。
该方法声明抛出ClassNotFoundException异常。顾名思义，当该方法无法获取需要装入的类时（例如，在当前类路径中不存在这个类），就会抛出这个异常。
例如，如果当前类路径中存在Foo类：
package org.whatisjava.reflect;
public class Foo
public Foo()
System.out.println("Foo()");
static
System.out.println("Foo is initialized");
运行下面的代码：
Class clazz = Class.forName("org.whatisjava.reflect.Foo");
控制台会有如下输出：
Foo is initialized
Class.forName("org.whatisjava.reflect.Foo")首先会将reflection.Foo类装入JVM，并返回与之关联的Class对象。JVM装入Foo类后对其进行初始化，调用了其static块中的代码。需要注意的是：forName方法的参数是类的完 整限定名（即包含包名）。
区别于前面两种获取Class对象的方法：使用Class.forName方法所要获取的与之对应的Class对象的类可以通过字符串的方式给定。该方法通常用于在程序运行时根据类名动态的载入该类并获得与之对应的Class对象。
通过上面的文章相信你对java的反射机制有了一定的认识,同时也对java中Class类的用法有了比较清晰的理解,在我们实际工作的过程中,我们不断的运用java知识来解决实际生活中的问题的时候我们就能对java反射机制有一个更深入的理解!
二、代码示例
1.ClassTest.java
[java] view plaincopy
/**
* java中Class类的使用
*/
import java.io.*;
import java.lang.reflect.*;
public class ClassTest1
public ClassTest1()
public static void main(String[] args) throws Exception
ClassTest1 test=new ClassTest1();
ClassTest1 test1=test.getClass().newInstance();
//test1=test;
test.printMessage();
test1.printMessage();
System.out.println(test.hashCode());
System.out.println(test1.hashCode());
Method[] method=test1.getClass().getMethods();
for(Method m :method)
System.out.println(m.getDeclaringClass());
System.out.println(m.getName());
public void printMessage()
System.out.println("Created successful!");
运行结果：
[plain] view plaincopy
Created successful!
Created successful!
14576877
12677476
class ClassTest1
printMessage
class ClassTest1
main
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
hashCode
class java.lang.Object
getClass
class java.lang.Object
equals
class java.lang.Object
toString
class java.lang.Object
notify
class java.lang.Object
notifyAll
2.TestClass.java
[java] view plaincopy
/**
*
*/
public class TestClass
public static void main(String[] args)
try
// 测试Class.forName()
Class testTypeForName = Class.forName("TestClassType");
System.out.println("testForName---" + testTypeForName);
// 测试类名.class
Class testTypeClass = TestClassType.class;
System.out.println("testTypeClass---" + testTypeClass);
// 测试Object.getClass()
TestClassType testGetClass = new TestClassType();
System.out.println("testGetClass---" + testGetClass.getClass());
catch (ClassNotFoundException e)
// TODO Auto-generated catch block
e.printStackTrace();
class TestClassType
// 构造函数
public TestClassType()
System.out.println("----构造函数---");
// 静态的参数初始化
static
System.out.println("---静态的参数初始化---");
// 非静态的参数初始化
System.out.println("----非静态的参数初始化---");
运行结果:
[plain] view plaincopy
---静态的参数初始化---
testForName---class TestClassType
testTypeClass---class TestClassType
----非静态的参数初始化---
----构造函数---
testGetClass---class TestClassType
分析：根据结果可以发现，三种生成的Class对象一样的，并且三种生成Class对象只打印一次“静态的参数初始化”。
java反射机制(创建class对象的三种方式)
1：SUN提供的反射机制的类：java.lang.Class<T>java.lang.reflect.Constructor<T>java.lang.reflect.Fieldjava.lang.reflect.Methodjava.lang.reflect.Modifier2：什么是反射JAVA反射机制是在运行状态中，对于任意一个类。都能都知道这个类的所有属性和方... 查看详情
java中反射的理解
记录是为了更好的成长！ 1、java加载class的三种方式publicstaticvoidmain(String[]args)throwsClassNotFoundException,InstantiationException,IllegalAccessException{//加载类的三种方式//1、使用new关键字方法Useruser=newUser();Method[]metho 查看详情
java反射获取class对象的三种方式，反射创建对象的两种方式(代码片段)
Java反射获取class对象的三种方式，反射创建对象的两种方式1、获取Class对象在JavaAPI中，提供了获取Class类对象的三种方法：第一种，使用Class.forName静态方法。前提：已明确类的全路径名。第二种，使用.class方法。说明：仅适合... 查看详情
java之反射(代码片段)
目录1.什么是反射机制2.反射机制有什么用3.Class类对象的三种实例化模式1.getClass()方法：2.类.class3.使用Class类提供的方法4.通过反射实例化对象5.反射主要使用的种类5.1Class类方法：5.2Field类方法5.3:Method方法1.什么是反射机... 查看详情
java反射机制(代码片段)
文章目录一、概念1.什么是反射？2.反射的用途3.反射的基本信息4.Class类(反射机制的起源)二、反射的使用1.获取Class类的三种方法2.创建对象3.反射私有的构造方法4.反射私有属性5.反射私有方法所有代码三、反射优点和缺点完&... 查看详情
java反射技术
1.什么是反射JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的... 查看详情
反射机制
一、什么是反射？Java反射说的是在运行状态中，对于任何一个类，我们都能够知道这个类有哪些方法和属性。对于任何一个对象，我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称... 查看详情
反射？？？
一、反射的概述java的反射指的是在程序运行时解析类的的内部信息，对于任意一个类，都能够知道其属性以及方法，而对于任意一个对象，也能调用它的方法及属性，这种可以动态获取信息的方法就称之为java的反射机制。二、... 查看详情
hibernate中java对象的三种状态
首先hibernate中对象的状态有三种：瞬态、游离态和持久态，三种状态转化的方法都是通过session来调用，瞬态到持久态的方法有save（）、saveOrUpdate（）、get（）、load（）；持久态到瞬态的方法有delete（）；游离态到持久态的方法... 查看详情
反射机制获取class对象的三种方式
1、通过getClass()方法：（通过对象）Classc1=obj.getClass(); 2、通过对象实例方法获取对象：（通过对象）Classc2=obj.class; 3、类的全路径：（通过类名）Classc3=Class.forName("package.className"); 查看详情
java的反射机制入门(代码片段)
理解Java的反射机制对学习Java框架有很大帮助，比如Spring框架的核心就是使用Java反射实现的，同时对做一些Java底层操作也会有帮助，比如字节码操作、自定义注解等。什么是反射Java反射说的是在运行状态中，对于任何一个类，... 查看详情
java之线程同步的三种方法
最近接触到一个图片加载的项目，其中有声明到的线程池等资源需要在系统中线程共享，所以就去研究了一下线程同步的知识，总结了三种常用的线程同步的方法，特来与大家分享一下。这三种方法分别是：synchronized代码段... 查看详情
java反射机制概述
一、反射 1、概述： JAVA反射机制是在运行状态中，对于任意一个类，都能够创建该类对象，调用这个类的所有属性和方法包括构造方法； 2、字节码文件 1)概述： 类加载器负责将.class文件加载到内在中，并为之生成对应的Clas... 查看详情
反射：获取class对象的三种方式(代码片段)
获取Class对象的三种方式 packagelianxiApril18;/***获取Class对象的三种方式*1Object——>getClass();*2任何数据类型（包括基本数据类型）都有一个“静态”的class属性*3通过Class类的静态方法：forName（StringclassName）(常用)**/publicclassFans... 查看详情
反射机制获取class对象的三种方式：
Personperson=newPerson();//1、通过Object类的getClass()方法：（需要先实例化一个对象）Classclazz1=person.getClass();//2、通过对象实例方法获取对象：（需要先实例化一个对象）Classclazz2=person.class;//3、类的全路径：（不许呀实例对象）Classclaz... 查看详情
html5结合css的三种方法+结合js的三种方法
HTML5+CSS：HTML中应用CSS的三种方法一、内联内联样式通过style属性直接套进HTML中去。示例代码<pstylepstyle="color:red">text</p> 这将会是指定的段落变成红色。我们的建议是，HTML应该是独立的、样式自由的文档，所以内联样... 查看详情
java实现定时任务的三种方法
java实现定时任务的三种方法详解java定时任务定时器的实现、java定时器介绍与Spring中定时器的配置java定时器简单了解 ------------------ java定时器执行多个方法 查看详情
js创建对象的三种方式
...的行为,在对象中用方法来表示(常用动词-功能)2.创建对象的三种方式在Java中，现阶段我们可以采用三种方式创建对象（object）利用字面量创建对象利用newObject创 查看详情