在正常的情况下，必须知道一个类的完整路径引入后，才可以按照固定的格式产生实例对象化，但是在java中，也可以通过一个实例化对象找到一个类的完整信息，那么这就是Class类的功能、
所谓反射程序的运行结果看来也很好理解，既可以通过对象反射求出类的名称。
正常方式：引入需要的包.类的名称 通过new实例化 取得实例化对象
反射方式：实例化对象-getClass()方法--得到完整的包.类的名称
所有的类的对象实际上都是Class类的实例
实例化对象实例：
public class one {
public static void main(String[] args) {
Class<?> c1=null;
Class<?> c2=null;
Class<?> c3=null;
try {
c1=Class.forName("x");
} catch (Exception e) {
e.printStackTrace();
}
c2=new x().getClass();
c3=x.class;
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c3.getName());
}
}
class x{
}
以上三种Class对象方式是一样的，但是使用forName（）的静态方法实例化Class对象是较为常见的一种方法。
Class类的 使用
通过无参构造实例化对象可以使用newInstance（）方法，但必须保证被实例化的对象存在一个无参的构造方法。
package com.wsl.prictise;
public class instance {
public static void main(String[] args) {
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
Person p1=null;
try {
p1=(Person)c1.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
p1.setAge(45);
p1.setName("王明");
System.out.print(p1.toString());
}
}
在java开发中，反射是最为重要的操作原理。
调用有参的构造方法
只是在操作时需要明确的调用类中的构造方法，并将参数传递进去以后可以进行实例化操作。操作步骤如下：
（1）通过Class类中的getCostructors（）取得本类中的全部构造方法。
（2）向构造方法中传递一个对象数组进去，里面包含了构造方法中所需要的各个参数。
package com.wsl.prictise;
import java.lang.reflect.Constructor;
public class Instancedemo {
public static void main(String[] args) {
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
Person p1=null;
Constructor<?> cons[]=null;
cons=c1.getConstructors();
try {
p1=(Person)cons[0].newInstance("理性化",20);
} catch (Exception e) {
e.printStackTrace();
}
System.out.print(p1);
}
}
3.取得类的结构
使用到java.lang.reflect包中的以下几个类：
Constructor：表示类中的构造方法
Field：表示类中的属性
Method：表示类中的方法、
这三个类都是AccessibleObject类的子类。
取得所实现的全部接口。
package com.wsl.prictise;
interface China{
public static final String NATION="China";
public static final String AUTHOR="王胜利";
public void saychina();
public String sayHello(String name,int age);
}
public class Person implements China{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+"年龄："+this.age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String sayHello(String name, int age) {
return name+",你好，我今年"+age+"岁了！";
}
@Override
public void saychina() {
System.out.println("作者："+AUTHOR+",国籍："+NATION);
}
}
package com.wsl.prictise;
import java.lang.reflect.Constructor;
public class Instancedemo {
public static void main(String[] args) {
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
Class<?> c[]=c1.getInterfaces();
for (int i = 0; i < c.length; i++) {
System.out.print("实现的接口名称是："+c[i].getName());
}
}
}
取得父类：
一个类可以实现多个接口，但是只能继承一个父类，所有如果要取得一个类的父类，可以直接使用Class类中的getSuperClass（）方法
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
Class<?> c=c1.getSuperclass();
System.out.println(c.getName());
取得全部构造方法：用getConstructors（）
4.取得全部方法：
要取得一个类中的全部方法，可以使用class类中的getMethods（）方法。此方法返回一个Method类的对象数组。
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
Method m[]=c1.getMethods();
for (int i = 0; i < m.length; i++) {
Class<?> r=m[i].getReturnType();
Class<?> p[]=m[i].getParameterTypes();
int xx=m[i].getModifiers();
System.out.print(Modifier.toString(xx));
System.out.print(r.getName());
System.out.print(m[i].getName());
System.out.print("(");
for (int j = 0; j < p.length; j++) {
System.out.print(p[j].getName()+""+"arg"+j);
if (j<p.length-1) {
System.out.print(",");
}
}
Class<?> ex[]=m[i].getExceptionTypes();
if (ex.length>0) {
System.out.print(") throws");
}
else {
System.out.print(")");
}
for (int k = 0; k < ex.length; k++) {
System.out.print(ex[k].getName());
if (k<ex.length-1) {
System.out.print(",");
}
}
System.out.println();
}
}
开发工具就是利用反射的原理、
在使用IDE进行程序开发时，基本上都是带随笔提示功能的，即使用了一个.就可以找到一个类的全部方法。
5.取得全部属性
在反射操作中，取得一个类的全部属性，但是在取属性时有两个不同的操作：
（1）得到实现的接口或父类中的公共属性，
Public Field（） getFields[] throws SecutityExecption
（2）得到本类中的全部属性：
Public Field[] getDeclaredFields() throws SecurityExction
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
{
Field f[]=c1.getDeclaredFields();
for (int i = 0; i < f.length; i++) {
Class<?> r=f[i].getType();
int no=f[i].getModifiers();
String priv=Modifier.toString(no);
System.out.print("本类属性");
System.out.print(priv+" ");
System.out.print(r.getName());
System.out.println(f[i].getName());
System.out.println(";");
}
}
}
6.通过反射调用类中的方法
（1）通过Class类的getMethod(String name，class...parameterTypes)方法 取得一个Method的对象，并设置此方法操作时所需要的参数类型
（2）之后可以使用invoke（）进行调用，并向方法中传递要设置的参数。
范例：
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
try {
Method mh=c1.getMethod("saychina");
mh.invoke(c1.newInstance());
e.printStackTrace();
}
Class<?> c1=null;
try {
c1=Class.forName("com.wsl.prictise.Person");
} catch (Exception e) {
e.printStackTrace();
}
try {
Method mh=c1.getMethod("saychina");
Method md=c1.getMethod("sayHello", String.class,int.class);
String rv=null;
rv=(String)md.invoke(c1.newInstance(), "王明",23);
mh.invoke(c1.newInstance());
System.out.print(rv);
} catch (Exception e) {
e.printStackTrace();
}
调用setter及getter方法
