java反射机制与动态加载类

什么是java反射机制？

1、当程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。我们认为java并不是动态语言，但是它却有一个非常突出的动态相关机制，俗称：反射。
IT行业里这么说，没有反射也就没有框架，现有的框架都是以反射为基础。在实际项目开发中，用的最多的是框架，填的最多的是类，反射这一概念就是将框架和类揉在一起的调和剂。所以，反射才是接触项目开发的敲门砖。

2、java中的new方法是静态加载，因为new方法是在编译阶段就会检查，而不是在运行阶段。反射是可以在运行时创建对象，调用对象的方法、变量等。

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

例如：

 package service.impl;

 public class Test {

     public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
         F f = new F();
         // 第一种表达方式
         Class c1 = F.class;// 这种表达方式同时也告诉了我们任何一个类都有一个隐含的静态成员变量class
         // 第二种表达方式
         Class c2 = f.getClass();// 这种表达方式在已知了该类的对象的情况下通过getClass方法获取
         // 第三种表达方式
         Class c3 = Class.forName("service.impl.F");// 类的全称

         System.out.println(c1.getName());
         System.out.println(c2.getName());
         System.out.println(c3.getName());
         F temp = (F) c1.newInstance();//这里可以是c1/c2/c3
         System.out.println(temp.f);
         temp.save();
     }
 }

 class F {
     public String f = "test";

     public void save() {
         System.out.println("save...");
     }
 }

运行结果：

service.impl.F
service.impl.F
service.impl.F
test
save...

动态加载：

如何动态加载一个类呢？
首先我们需要区分什么是动态加载？什么是静态加载？我们普遍认为编译时刻加载的类是静态加载类，运行时刻加载的类是动态加载类。

例如:

 Class A{
  　　Public static void main(String[] args){
 　　　　if("B".equal(args[0])){
 　　　　　　B b=new B();
 　　　　　　b.start();
 　　　　}
 　　　　if("C".equal(args[0])){
 　　　　　　C c=new C();
 　　　　　　C.start();
 　　　　}
 　　}
 }

上面程序编译时会报错，当我们直接在cmd使用javac访问A.java类的时候，就会抛出问题:

但是如果我们动态加载就可以满足（参数不为“B”或者“C”时候，本应该可以运行）

如：

 package service.impl;

 public class Test2 {

     public static void main(String[] args) throws InstantiationException, IllegalAccessException {

             Class b = null;
             try {
                 b = Class.forName("service.impl.B");
             } catch (ClassNotFoundException e) {
                 System.err.println("something is wrong!!!");
                 e.printStackTrace();
             }
             Stand stand = (Stand)b.newInstance();
             stand.start();

     }
 }

 interface Stand{
     void start();
 }

 class B implements Stand{

     public void start() {
         System.out.println("B...start");
     }

 }

 class C implements Stand{

     public void start() {
         System.out.println("C...start");
     }

 }

运行结果：

B...start

如果以后想用某一个类，不需要重新编译，只需要实现这个标准的接口即可。只需要动态的加载新的东西就行了。
这就是动态加载类