什么是Java的反射机制

Java反射机制是Java的特点，是框架实现的基础，百度结果：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。java通常是先有类再有对象，有对象我就可以调用方法或者属性。反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理，精简总结一下：

1.什么是反射
答：就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成对象。类在运行的时候，可以得到该类的信息，并且 可以动态的修改这些信息，自己能看到自己，跟照镜子一样，也就是说Java的反射机制是在编辑的时候并不确定哪个类被加载了，而是在程序运行的时候才加载、探知、自审，使用在编译期并不知道的类，这样的特点就是反射。
2.那么Java反射有什么作用呢？ 
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。 当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行 选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。 
3.反射技术大量用于Java设计模式和框架技术，最常见的设计模式就是工厂模式和单例模式。 
单例模式(Singleton) 
       这个模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间，保证我们所访问到的都是同一个对象。 

       单例模式要求保证唯一，那么怎么样才能保证唯一性呢？对了，这就是静态变量。单例模式有以下两种形式： 

第一种形式： 
package reflect; 
public class Singleton {  
    private Singleton() { 
    }  
    private static Singleton instance = new Singleton(); 
    // 这里提供了一个供外部访问本class的静态方法，可以直接访问 
    public static Singleton getInstance() { 
           return instance; 
    }    
} 
class SingRun{ 
    public static void main(String[] args){ 
       //这样的调用不被允许，因为构造方法是私有的。 
       //Singleton x=new Singleton();      
       //得到一个Singleton类实例 
       Singleton x=Singleton.getInstance();   
       //得到另一个Singleton类实例 
       Singleton y=Singleton.getInstance();     
       //比较x和y的地址，结果为true。说明两次获得的是同一个对象 
       System.out.println(x==y); 
    } 
} 
第二种形式： 
public class Singleton { 
    //先申明该类静态对象 
    private static Singleton instance = null;   
    //创建一个静态访问器，获得该类实例。加上同步，表示防止两个线程同时进行对象的创建 
    public static synchronized Singleton getInstance() {      
       //如果为空，则生成一个该类实例 
       if (instance == null){ 
           instance = new Singleton(); 
       } 
       return instance; 
    } 
} 

工厂模式（Factory） 
       工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。 
为什么工厂模式是如此常用？是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发，可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码，而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。之前说利用接口可以将调用和实现相分离。那么这是怎么样去实现的呢？工厂模式可以为我们解答。 
我们先来回顾一下软件的生命周期，分析、设计、编码、调试与测试。其中分析就是指需求分析，就是知道这个软件要做成什么样子，要实现什么样的功能。功能知道了，这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目，如果让一个项目团队并行开发。这时候，通常先设计接口，把接口给实现接口的程序员和调用接口的程序员，在编码的时候，两个程序员可以互不影响的实现相应的功能，最后通过配置文件进行整合。 
代码示例： 
interface InterfaceTest{ 
    public void getName();//定义获得名字的方法 
} 
接口有了，那么得到这个接口，进行实现编码的程序员应该怎么做呢？对了，实现这个接口，重写其中定义的方法 
接口实现方法： 
class Test1 implements InterfaceTest{ 
    public void getName() { 
       System.out.println("test1"); 
    } 
} 
class Test2 implements InterfaceTest{ 
    public void getName() { 
       System.out.println("test2"); 
    } 
   
} 
大家可以发现，当接口定义好了以后，不但可以规范代码，而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管，这个类要被谁去调用。 那么怎么能获得这些程序员定义的对象呢？在工厂模式里，单独定义一个工厂类来实现对象的生产，注意这里返回的接口对象。 
工厂类，生产接口对象：
class Factory{ 
    //创建私有的静态的Properties对象 
    private static Properties pro=new Properties(); 
    //静态代码块 
    static{ 
       try {        
           //加载配置文件 
           pro.load(new FileInputStream("file.txt")); 
       } catch (Exception e) { 
           e.printStackTrace(); 
       } 
    } 
    private static Factory factory=new Factory(); 
    private Factory(){}   
    public static Factory getFactory(){ 
       return factory; 
    } 
    public  InterfaceTest getInterface(){ 
       InterfaceTest interfaceTest=null;//定义接口对象     
       try { 
           //根据键，获得值，这里的值是类的全路径 
           String classInfo=pro.getProperty("test");  
           //利用反射，生成Class对象 
           Class c=Class.forName(classInfo);  
           //获得该Class对象的实例 
           Object obj=c.newInstance(); 
           //将Object对象强转为接口对象 
           interfaceTest=(InterfaceTest)obj; 
       } catch (Exception e) { 
           e.printStackTrace(); 
       } 
       //返回接口对象 
       return interfaceTest; 
    } 
} 
配置文件内容： 
test=factory.Test2 
通过这个类，大家可以发现，在调用的时候，得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候，我们并没有直接把类的 全路径写出来，而是通过键获得值。这样的话，就有很大的灵活性，只要改变配置文件里的内容，就可以改变我们调用的接口实现类，而代码不需做任何改变。在调 用的时候，我们也是通过接口调用，甚至我们可以连这个接口实现类的名字都不知道。 
调用方法： 
public class FactoryTest { 
    public static void main(String[] args) { 
       //获得工厂类的实例 
       Factory factory=Factory.getFactory(); 
       //调用获得接口对象的方法，获得接口对象 
       InterfaceTest inter=factory.getInterface(); 
       //调用接口定义的方法 
       inter.getName(); 
    } 
} 
上面的代码就是调用方法。大家可以发现，在调用的时候，我们根本没有管这个接口定义的方法要怎么样去实现它，我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个 类里实现接口的方法，这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1 这个类里实现接口的方法，这时候打印“test1”。