初识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的反射机制会破坏单例模式……