Java动态加载机制
动态加载就是需要某个类的时候才对其进行加载，而不是对所有的类加载完成后才开始执行main方法。(需要看虚拟机详细的加载输入，需要对虚拟机输入 -verbose:class 参数)
public class Test{
public static void main(String[] args){
new A();//看到A才加载A，此时B还没有被加载
System.out.println("=======");//横线会被打印在加载A和加载B之间
new B();//看到B才加载B
new C();
new C();//new了两次C却只有一次输出
new D();
new D();//new两次D就两次输出
}
}
class A{
}
class B{
}
class C{
static{//在加载完成后被调用，且只调用一次
System.out.println("静态语句块，不管new多少个对象只会执行一次");
}
}
class D{
{//动态语句块，和构造方法差不多，用得少
System.out.println("没每new一个对象执行一次");
}
}
JDK中的ClassLoader
包含四个ClassLoader，bootstrap class loader是用本地语言写的，别的class loader用java写的。
bootstrap class loader加载别的class loader，然后别的class loader被加载完成之后，再去加载另外的class。
在java中，每个class都有一个Class对象，当编译完一个.class文件后，就会产生一个Class对象，用以描述这个类的类型信息
package com.scriptwang;
public class Test{
public static void main(String[] args) throws Exception{
//三种方法可以拿到Test类的Class对象
Class a = new com.scriptwang.Test().getClass();//getClass继承自Object
Class b = com.scriptwang.Test.class;//个人理解相当于每个类都有一个Class class的成员变量，是public的，通过类名.属性名可以拿到该成员变量。
Class c = Class.forName("com.scriptwang.Test");//通过Class类的forName("完整的类名")
//拿到加载Test类的CLassLoader的名字
/*
Class c ＝ Test.class;//返回Test类的Class对象
ClassLoader cl = c.getClassLoader();//返回ClassLoader实例
Class d ＝ cl.getClass();//拿到ClassLoader类的Class对象
(ClassLoader本身也是一个java类，getClass方法继承自Object类)
String name ＝ d.getName();//拿到Class对象返回的类的名字
*/
System.out.println(Test.class.getClassLoader().
getClass().getName());
}
}
ClassLoader的层次关系（不是继承，继承是从类的角度说的，层次是对象和对象之间的关系）
application class loader对象里面有一个引用，叫做Parent，指向extension class loader，同理，extension class loader有一个Parent指向bootstrap class loader（可以这么认为，因为bootstrap class loader是用本地的语言写的，不能被指向）
通过getParent方法可以拿到上一个层次的class loader，因此可以用循环遍历class loader对象。不是类继承，不是类继承，不是类继承，重要的事情说三遍。
设置这样的层次关系的目的：当加载一个类的时候，会通过检查（一直检查到root class loader）上一层次的Class Loader是否加载，如果上一个层次加载过了，那么当前的Class Loader就不会加载这个类。比如：自己写的java.lang.String永远不会被加载！这样可以保证安全性。
public class Test{
public static void main(String[] args){
//拿到加载Test类的CLassLoader
ClassLoader c = Test.class.getClassLoader();
//通过循环遍历ClassLoader
while (c != null ){
System.out.println(c.getClass().getName());
c = c.getParent();//拿到上一层次的ClasLoader
}
}
}
反射机制
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
JAVA反射（放射）机制："程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言"。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods
import java.lang.reflect.Method;
public class Test{
public static void main(String[] args) throws Exception{
String className = "Test";
Class c = Class.forName(className);//通过class名拿到Class对象
Object instance = c.newInstance();//通过Class对象new这个类的对象
Method[] methods = c.getMethods();//通过Class对象获得Method对象
for (int i=0;i<methods.length;++i){
if (methods[i].getName() == "m"){
methods[i].invoke(instance,12);
}
}
}
public void m(int i){
System.out.println(i);
}
}
/*
forName会抛出ClassNotFoundException
newInstance会抛出InstantiationException、IllegalAccessException
invoke会抛出IllegalAccessException、InvocationTargetException
*/
比如这样一个例子，有一个接口叫做Animal，它有方法enjoy、eat、sleep，所有实现了这个接口的具体类（比如Cat、Dog）都拥有这些方法，因此，在通过反射机制new具体对象的时候，反射机制的代码并不用改变（因为具体的类的方法都是依据接口固定化了的）。
public interface Animal {//定义一个接口
public void enjoy(String thing);
public void eat();
}
public class Dog implements Animal{//实现了Animal接口的Dog
public void enjoy(String thing){
System.out.println("Dog is enjoy " + thing);
}
public void eat(){
System.out.println("Dog is eatting");
}
}
public class Cat implements Animal {//实现了Animal借口的Cat
public void enjoy(String thing){
System.out.println("Cat is enjoy "+ thing);
}
public void eat(){
System.out.println("Cat is eatting");
}
}
import java.lang.reflect.Method;//引入相关的类
public class UserClass {
public static void main(String[] args) throws Exception{
//不管从配置文件获得的类名是Cat还是Dog都可以传进来，只要实现了Animal接口的具体类都可以传入，以下的代码照样适用，因为它们都实现了Animal接口（里面的方法申明都是一样的，只不过每个类具体的实现方式不一样而已，这样就实现了很好的扩展性）
String className = "Cat";
Class c = Class.forName(className);
Object o = c.newInstance();
Method[] methods = c.getMethods();
for (int i=0;i<methods.length;++i){
if (methods[i].getName() == "enjoy"){
methods[i].invoke(o,"playing");
}
if (methods[i].getName() == "eat"){
methods[i].invoke(o);
}
}
}
}
反射机制的一些相关应用（创建对象、访问Field、调用方法、重写toString）
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* Created by Script Wang on 2016/11/27.
*/
class Student {
private String name;
private int age;
Student (){
name = "";
age = 0;
}
Student (String name,int age){
this.name = name;
this.age = age;
}
public void m(){
System.out.println("I am invoked ===== !!!");
}
/**
*
* @return
* 利用反射重写toString
*/
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
Field[] fields = this.getClass().getDeclaredFields();//拿到所有成员变量
//循环成员变量，将变量名值添加到sb中
for (int i=0;i<fields.length;i++){
sb.append(fields[i].getName());//拿到当前Field的名字
sb.append(" = ");//添加等号
try{
sb.append(fields[i].get(this));//拿到当前Field的值
}catch (IllegalAccessException e){
e.printStackTrace();
}
//如果遇到最后一个变量，则末尾不添加分号
if (i != fields.length - 1){
sb.append(" ; ");
}
}
//返回sb的toString
return sb.toString();
}
}
public class TestReflect {
public static void main(String[] args){
test1();//打印示例：name = SW ; age = 21
test2();//打印示例：name = SW ; age = 22
test3();//打印示例：I am invoked ===== !!!
}
/**
* 用反射中的Constructor构建对象
*/
public static void test1(){
Class clazz = null;
Constructor con = null;
Student s = null;
try{
clazz = Class.forName("Student");//抛ClassNotFoundException
con = clazz.getDeclaredConstructor(String.class,int.class);//抛NoSuchMethodException
s = (Student) con.newInstance("SW",21);//抛剩下的三个Exception
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (NoSuchMethodException e){
e.printStackTrace();
}catch (InstantiationException e){
e.printStackTrace();
}catch (IllegalAccessException e){
e.printStackTrace();
}catch (InvocationTargetException e){
e.printStackTrace();
}
System.out.println(s);
}
/**
* 用反射为成员变量赋值构建对象（需要被构建对象的类有空的构造方法）
* 需要知道构造函数需要哪些类型的参数
*
*/
public static void test2(){
Class clazz = null;
Object obj = null;
Field[] fields = null;
try{
clazz = Class.forName("Student");//抛ClassNotFoundException
obj = clazz.newInstance();//抛剩下的两个Exception
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (InstantiationException e){
e.printStackTrace();
}catch (IllegalAccessException e){
e.printStackTrace();
}
//拿到所有Field并循环
fields = clazz.getDeclaredFields();
for (Field f : fields){
f.setAccessible(true);//这句相当重要，可以访问private的变量
try {
//get方法会抛IllegalAccessException
if (f.get(obj) instanceof String){
f.set(obj,"SW");//为当前obj 赋值
} else if (f.get(obj) instanceof Integer){
f.set(obj,22);
}
}catch (IllegalAccessException e){
e.printStackTrace();
}
}
System.out.println( (Student)obj );
}
/**
* 利用反射调用方法
*/
public static void test3(){
Class clazz = null;
Object obj = null;
Method[] methods = null;
try{
clazz = Class.forName("Student");//抛ClassNotFoundException
obj = clazz.newInstance();//抛剩下的两个Exception
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (InstantiationException e){
e.printStackTrace();
}catch (IllegalAccessException e){
e.printStackTrace();
}
//拿到所有的Method对象并循环
methods =clazz.getDeclaredMethods();
for (Method m : methods){
if (m.getName().equals("m")){
m.setAccessible(true);
try {
m.invoke(obj);//调用obj的方法，抛出以下两个Exception
}catch (IllegalAccessException e){
e.printStackTrace();
} catch (InvocationTargetException e){
e.printStackTrace();
}
}
}
}
}