初识Java反射机制

1.ClassLoader的类加载机制：并非一次性加载，而是需要的时候加载(运行期间动态加载)(Class文件加载到内存的代码段)，static语句块在加载后执行一次。dynamic语句块（就是一个语句块，用大括号括起来）每次new新的对象都会执行，等同于构造方法中的语句，只不过加载到构造方法之前，用的较少。

注意参数的大小写，也不要多加空格。

看下面这个例子：

 public class Dynamic {

     public static void main(String[] args) {
         new A();//不是一次性加载，从结果看出这个分割线的位置
         System.out.println("___________________");
         new B();

         new C();
         new C();

         new D();
         new D();
     }

 }

 class A {

 }

 class B {

 }

 class C {
     static {
         System.out.println("——————————————静态类加载——————————————");
     }
 }

 class D {
     {
         System.out.println("************动态类加载***********");
     }
 }

下面是未加-verbose：class的结果：

___________________
——————————————静态类加载——————————————
************动态类加载***********
************动态类加载***********

下面是加参数后的结果：

2.verbose：冗长的详细的

3.JDK里的类加载器很多。
4.bootstrap：启动节点，引导节点。

 public class TestJDKClassLoader {

     public static void main(String[] args) {
         System.out.println(String.class.getClassLoader());
         //System.out.println(com.sum.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());
         System.out.println(TestJDKClassLoader.class.getClassLoader());
         System.out.println(ClassLoader.getSystemClassLoader());
     }

 }

null
sun.misc.Launcher$AppClassLoader@45a1472d
sun.misc.Launcher$AppClassLoader@45a1472d

5.ClassLoader类在java.lang包里

 public class TestJDKClassLoader {

     //getClass可以获取一个类的定义信息，然后使用反射去访问其全部信息(包括函数和字段)
     public static void main(String[] args) {
         ClassLoader c = TestJDKClassLoader.class.getClassLoader();
         while(null!=c) {
             System.out.println(c.getClass().getName());
             //虽然叫parent但并不是继承
             c = c.getParent();
         }
     }

 }

sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader

6.对象.getClass相当于类名.class。

7.properties文件

　　　参考资料：http://blog.csdn.net/netwarning/article/details/1569900

　　properties文件顾名思义就是属性文件，可以在它里面定义一些字段，这将不需要我们在代码中书写，这些信息从代码中分离出来了。看下面的例子：

　　注意在文件里面就不需要加分号。

 //文件名为myProperties.properties

 String driver = "com.mysql.jdbc.Driver"
 String url = "jdbc:mysql://localhost/myDB";
 String name = "root"
 String password = "123"

 //***************************
 Class.forName(driver);
 Connection con = DriverManager.getConnection(url,name,password);

 //**************************
 String driver;
 String url;
 String name;
 String password; 

 FileInputStream fis = new FileInputStream(myProperties.properties);
 Properties properties = new Properties();
 properties.load(fis);            //从输入流中读取属性文件的内容
 fis.close();
 //从属性文件中读取相应字段的信息
 driver = properties.getProperty(driver);
 url = properties.getProperty(url);
 name = properties.getProperty(name);
 password = properties.getProperty(password);

 Class.forName(driver);
 Connection con = DriverManager.getConnection(url,name,password);

 /*
 我们看到数值和代码已经分离，这样很方便我们修改数值！
 再有一定要注意properties文件中的字段的写法，不要再多添“”否则会出现问题！
 因为getProperty()方法返回的是一个字符串！

 我想应该再对这个文件做一下加密处理会更好一些是吧？
 */

　　8.Java语言不够动态，真正动态的语言是JS、Ruby和Python。
　　9.java的反射机制很重要，是学习SSH的基础以及面向切面编程Aspect Oriented Programming(AOP)。
　　10.RC就是Release Candidate（候选版本）的简称。从微软的惯例来看OS的开发步骤是这样的：内部测试->alpha公测->beta公测->RC版->正式版上市。
　　11.下面是反射机制的例子：

 package a;

 import java.lang.reflect.Method;

 /*
  * properties文件里只有class=T，注意没有问号
  * 实现了代码和数据的分离，这样不必写死
  * 问题：知道类名字，然后new出来一个
  */

 //学习SSH时类的名字很多时候都是在配置文件里的
 public class TestReflection {

     public static void main(String[] args) throws Exception {
         /*
          * 使用new创建一个类的时候，这个类可以没有被加载。
          * 但是使用newInstance（）方法的时候，
          * 就必须保证这个类已加载且类已经连接了。
          */
         String str = "a.T";//到时候这个换成从文件里读取,靠，必须写完整路径

         Class c = Class.forName(str);//加载类
         /*
          * newInstance和new的区别在于一个方法一个关键字
          * 且前者要求类已经加载了才可实例化
          */
         Object obj = c.newInstance();
         Method[] methods = c.getMethods();
         for(Method m: methods) {
             //System.out.println(m.getName());
             if(m.getName().equals("myMehtod")) {
                 //不能是c或者T.class，因为方法
                 /*
                  * invoke方法是可变参数的方法，传递0个或者多个参数
                  * 主要是因为不知道传递几个参数
                  */
                 m.invoke(obj,2);//必须是obj，不能是c，方法的调用是对象
                 for(Class paramType : m.getParameterTypes()) {
                     System.out.println(paramType.getName());
                 }
             }

             if(m.getName().equals("getS")) {
                 Class returnType = m.getReturnType();
                 System.out.println(returnType.getName());
             }
         }

     }

 }

 class T {
     //static块的用法http://www.cnblogs.com/hxsyl/archive/2013/04/16/3024953.html
     static {//类加载时执行
         System.out.println("T loaded");//就是为了证明类已经加载
     }

     public T() {
         System.out.println("T constructed");
     }

     int i;
     String s;

     public void myMehtod(int i) {
         this.i = i;
         System.out.println("方法调用");
     }

     public String getS() {
         return s;
     }
 }

12.理解invoke方法

 package a;

 /*
  * 下面这个是网上的代码，找了好久还就这一个
  * 看了也还是没明白invoke方法
  */
 import java.lang.reflect.Method;

 public class InvokeTester {

     public int add(int param1, int param2) {
         return param1 + param2;
     }

     public String echo(String msg) {
         return "echo:" + msg;
     }

     public static void main(String[] args) throws Exception {
         Class classType = InvokeTester.class;
         Object invokertester = classType.newInstance();

         Method addMethod = classType.getMethod("add", new Class[] { int.class,
                 int.class });
         // Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，
         // 如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，
         // 如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，
         // 再将其返回
         Object result = addMethod.invoke(invokertester, new Object[] {
                 new Integer(100), new Integer(200) });
         // 在jdk5.0中有了装箱 拆箱机制 new Integer(100)可以用100来代替，系统会自动在int 和integer之间转换
         System.out.println(result);

         Method echoMethod = classType.getMethod("echo",
                 new Class[] { String.class });
         result = echoMethod.invoke(invokertester, new Object[] { "hello" });
         System.out.println(result);
     }
 }

　　13.java的反射机制会破坏单例模式……