反射机制主要指的是什么？ 在java里面都是有哪些API和方法来实现？ 他们的主要用途是什么？

了解了构造器，其实可以猜到成员变量的获取方法了，成员变量用Field类进行封装。
主要的方法非常的类似：
public Field getDeclaredField(String name)  获取任意指定名字的成员
public Field[] getDeclaredFields()             获取所有的成员变量
public Field getField(String name)           获取任意public成员变量
public Field[] getFields()                          获取所有的public成员变量
  　 可以看出这些方法都是异曲同工的，好了直接看一下例子吧

/**
* 获取成员变量Field
* getField()
* getDeclaredField()
* */
Field mem = cls1.getDeclaredField("name");
mem.setAccessible(true);
System.out.println("we get form field :"+mem.get(obj));
这是在访问私有变量。

封装类的方法的类是Method.获取method也有四个方法
public Method[] getMethods()    获取所有的共有方法的集合
public Method getMethod(String name,Class<?>... parameterTypes) 获取指定公有方法 参数1：方法名 参数2：参数类型集合  
public Method[] getDeclaredMethods()  获取所有的方法
public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取任意指定方法
       看下面的例子吧

/**
* 调用类的方法 Method
* getMethod()
* getDeclaredMethod()
*
* */
Method f = cls1.getMethod("getName", null);
Object name = f.invoke(obj, null);
System.out.println("we invoke method : "+ name);
无参的时候我们只要传null就行了。
----------------------------------------------------------------------
以上就是反射机制的简单的使用
学过spring就可以明白，可以通过配置文件就可以让我们获得指定的方法和变量，在创建对象的时候都是通过传进string实现的，就好像你需要什么，我们去为你生产，还有我们一直在用Object,这就说明java语言的动态特性，依赖性大大的降低了。我看了这些例子之后理解了不少，有点多，可以仔细看看，或许会对你理解这个有很大的帮助

反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。
例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。这个能特定我们不常看到，但是在其他的比如C或者C++语言中很不就存在这个特性。
一个常见的例子是在JavaBean中，一些组件可以通过一个构造器来操作。这个构造器就是用的反射在动态加载的时候来获取的java中类的属性的。
--------------------------------------------------------------------------------------------------
java中有一个类很特殊，就是Class类，可以把它理解为封装了类的信息，很多解释说Class类没有构造器，其实是有的，只不过它的构造方法是private的（构造函数还有private的？？有，这样是为了禁止开发者去自己创建Class类的实例）。
（注释很明确的告诉了我们，这个类是有JVM来创建的，所以我们就不用麻烦了。如果我们拿到一个类的类型信息，就可以利用反射获取其各种成员以及方法了。（注：Class 从JDK1.5版本后就开始更多为泛型服务了）
举例：我们有一个Role类：

1. package yui;
   
2. 
   
3. /**
   
4.   * A base class having some attributes and methods
   
5.   * @author Octobershiner
   
6.   * @since 2012 3 17
   
7.   *
   
8.   * */
   
9. public class Role {
   
10.      
    
11.      private String name;
    
12.      private String type;
    
13.      
    
14.      // Constructors
    
15.      public Role(){
    
16.          System.out.println("Constructor Role() is invoking");
    
17.      }
    
18.      //私有构造器
    
19.      private Role(String name){
    
20.          this.name = name;
    
21.          System.out.println("Constructor Role(String name) is invoking.");
    
22.      }
    
23.      
    
24.      //get and set method
    
25.      
    
26.      public String getName() {
    
27.          return name;
    
28.      }
    
29.      public void setName(String name) {
    
30.          this.name = name;
    
31.      }
    
32.      public String getType() {
    
33.          return type;
    
34.      }
    
35.      public void setType(String type) {
    
36.          this.type = type;
    
37.      }
    
38.      
    
39.      //override the toString method to show the class
    
40.      @Override
    
41.      public String toString(){
    
42.          return "This is a role called "+this.name;
    
43.      }
    
44.      
    
45. }

复制代码

在没有对象实例的时候，主要有两种办法。
//获得类类型的两种方式
        Class cls1 = Role.class;
        Class cls2 = Class.forName("yui.Role");

Constructor类，这个类用来封装反射得到的构造器，Class有四个方法来获得Constructor对象

public Constructor<?>[] getConstructors()      返回类中所有的public构造器集合，默认构造器的下标为0

public Constructor<T> getConstructor(Class<?>... parameterTypes)   返回指定public构造器，参数为构造器参数类型集合

public Constructor<?>[] getDeclaredConstructors()  返回类中所有的构造器，包括私有

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回任意指定的构造器

从名字来看，还是很好懂的，带上Declared的都是获得所有的构造方法，包括私有，哈，这下我们就可以调用原本不允许调用的私有构造器了，看代码

1. /**
   
2.           * 获取构造方法Constructor
   
3.           * getConstructor()  only for public
   
4.           * getDeclaredConstructor()  global access all
   
5.           *
   
6.           * */
   
7.          
   
8.          //指定参数列表获取特定的方法
   
9.          Constructor con = cls1.getDeclaredConstructor(new Class[]{String.class});
   
10.          con.setAccessible(true); //设置可访问的权限
    
11.          Object obj = con.newInstance(new Object[]{"liyang"});
    
12.          System.out.println(obj);  //打印一下这个对象的信息
    
13.          
    
14. //获取所有的构造方法集合
    
15.          Constructor con1[] = cls1.getDeclaredConstructors();
    
16.          con1[1].setAccessible(true);
    
17.          Object obj1 = con1[1].newInstance(new Object[]{"tom"});
    
18.          System.out.println(obj1);

复制代码

第一个是获得一个指定的方法，我们指定了参数是一个String类型，第二段我们获得了所有的构造方法集合，并选取了其中一个创建了新的对象。注意这里Constructor的newInstance方法就可以设置参数了，与文章前面的同样的方法形成了对比。
四个方法全部需要抛出异常，当我们获得私有的方法的时候，要用setAccessible设置一下可访问的权限，例子中没有演示获取共有方法，那个比较简单，就不做介绍了，其实掌握了上面两个，其他就好理解了。

做框架，如果不做框架，基本没有用，这是张老师说的，
对于什么框架，我也不知怎么表达，
举个例子：动态代理，正是应用了反射机制，才得已实现的
要理解反射，主要是从Class这个类开似吧，Class类是描述java类的类，最好是多看张老师加强视频，说得很清楚易懂