1、JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。( 见百度百科)

2、主要功能：Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

1、通过类名，获取类具有的方法和属性

首先，定义一个类用于后面的操作

public class Coordinate {

  private float x;
  private float y;
  private float z;

  public float threshold = 0.001f;      //阙值

  public float getX() {
    return x;
  }

  public void setX(float x) {
    this.x = x;
  }

  public float getZ() {
    return z;
  }

  public void setZ(float z) {
    this.z = z;
  }

  public float getY() {
    return y;
  }

  public void setY(float y) {
    this.y = y;
  }

  //无参构造函数
  public Coordinate() {
    this.x = 0;
    this.y = 0;
    this.z = 0;
  }

  public Coordinate(float x, float y, float z) {
    this.x = x;
    this.y = y;
    this.z = z;
  }

  //判断两个坐标是否相等
  private boolean isEqual(Coordinate other) {
    if (Math.abs(other.getX() - this.getX()) > threshold) return false;
    if (Math.abs(other.getY() - this.getY()) > threshold) return false;
    if (Math.abs(other.getZ() - this.getZ()) > threshold) return false;
    return true;
  }

  //输出属性
  public void showThings() {
    System.out.println("X:" + x + " Y:" + y + " Z:" + z);
  }

  public void showThings(String name) {
    System.out.println(name + " X:" + x + " Y:" + y + " Z:" + z);
  }

}

获取类的信息

    package ReflectDemo2;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;

public class ClassDetail {

  private Class aClass;

  public ClassDetail(String className) {
    try {
      aClass = Class.forName(className);
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }

  //获得方法的详细信息
  public void getMethodsDetail() {
    Method[] methods = aClass.getDeclaredMethods();
    for (Method method : methods) {
      //这里就可以利用Method类里的众多的get方法获得它的信息了
      System.out.print(Modifier.toString(method.getModifiers()));
      System.out.print(" " + method.getReturnType());
      System.out.print(" " + method.getName() + '(');
      Parameter[] parameters = method.getParameters();
      int length = parameters.length;
      if (length > 0) {
        for (int i = 0; i < length - 1; ++i) {
          System.out.print(parameters[i].getType() + " " + parameters[i].getName() + ",");
        }
        System.out.print(parameters[length - 1].getType() + " " + parameters[length - 1].getName());
      }
      System.out.print(")" + '\n');
    }
  }

  //获得属性的详细方法
  public void getFieldDetail() {
    //getDeclaredFields获得所有的属性，getFields获得非私有的
    Field[] fields = aClass.getDeclaredFields();
    for (Field field : fields) {
      System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getType() + " " + field.getName());
    }
  }
}

调用

public class RfMain {

  public static void main(String[] args) {
    ClassDetail detail = new ClassDetail("ObjectDemo.Coordinate");
    detail.getMethodsDetail();
    detail.getFieldDetail();
  }
}

输出结果

private boolean isEqual(class ObjectDemo.Coordinate arg0)
public float getX()
public void setX(float arg0)
public float getY()
public void setY(float arg0)
public float getZ()
public void setZ(float arg0)
private float x
private float y
private float z
public float threshold

2、利用反射机制构造类对象，调用类的方法

无参数构造，无参数方法的调用

public static void main(String[] args) {
  try {
    Class cls = Class.forName("ObjectDemo.Coordinate");
    Object object = cls.newInstance();
    Method method = cls.getMethod("showThings");
    method.invoke(object);
  } catch (Exception e) {
    e.printStackTrace();
  }
}

结果：

X:0.0 Y:0.0 Z:0.0

有参数构造，无参数方法的调用

public static void main(String[] args) {
  try {
    Class cls = Class.forName("ObjectDemo.Coordinate");
    Constructor cons = cls.getConstructor(float.class, float.class, float.class);
    Object object = cons.newInstance(2, 3, 4);

    Method method = cls.getMethod("showThings");
    method.invoke(object);
  } catch (Exception e) {
    e.printStackTrace();
  }
}

结果：

X:2.0 Y:3.0 Z:4.0

无参数构造，有参数方法的调用

public static void main(String[] args) {
  try {
    Class cls = Class.forName("ObjectDemo.Coordinate");
    Object object = cls.newInstance();
    Method method = cls.getMethod("showThings", String.class);
    method.invoke(object, "Quincy say:");
  } catch (Exception e) {
    e.printStackTrace();
  }
}

结果：

Quincy say: X:0.0 Y:0.0 Z:0.0

反射就学习到这里了，那它到底有什么用呢？呵呵！！！现在我们就来说一个它的应用吧,例如数据库操作，我们定义了一些和数据库的表结构相同的类，我们就可以利用反射机制生成sql语句，而且只要写一次，是不是很方便？