Java类加载机制初探.doc

类加载机制初探
记得在刚学JAVA的时候,类的加载机制和初始化顺序经常被弄的糊里糊涂,其实当我们不太了解某些事情的时候,不防去做一做实验,让代码的运行结果说话,这或许能帮助我们更好地了解一些事情.今天我们就用一些代码来看一下类是如何被加载的,并且当有继承关系的时候,类的加载顺序又是怎么样的.

先看代码吧
/*
 * Test4.java
 * 
 * Created on 2007-9-21, 9:33:31
 * 
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package test1;

/**
 *
 * @author hadeslee
 */
public class Test4 {
    private void testClassForName(String name) throws ClassNotFoundException{
        Class c=Class.forName(name);
    }
    private void testNewInstance(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        Class c=Class.forName(name);
        Object obj=c.newInstance();
        System.out.println(obj);
    }
    public static void main(String[] args)throws Exception {
        Test4 t=new Test4();
        t.testClassForName("test1.B");
        new B();
        new B();
    }
}
class A{
    private int aj;
    {
        aj=20;
        System.out.println("A成员初始化块");
    }
    private static int ai;
    static {
        ai=10;
        System.out.println("A静态初始化块");
    }
    public A(){
        System.out.println("A构造函数");
    }
}
class B extends A{
    private static int bi;
    static {
        bi=30;
        System.out.println("B静态初始化块");
    }
    private  int bj;
    {
        bj=40;
        System.out.println("B成员初始化块");
    }
    public B(){
        System.out.println("B构造函数");
    }
}

在代码里面我们总共有三个类,一个是做测试用的Test4,一个是A,一个是A的子类B,我们在A和B类里面都有很多输出,一个是静态初始化的输出,一个是成员初始化的输出,一个是在构造函数里面的输出,从这些输出我们可以知道代码的执行顺序,以上代码运行输出如下:

A静态初始化块
B静态初始化块
A成员初始化块
A构造函数
B成员初始化块
B构造函数
A成员初始化块
A构造函数
B成员初始化块
B构造函数

从上面我们可以看出,A和B的静态初始化块只被执行了一次,也就是类的对象将要被生成的时候,它会执行,并且执行的顺序如下:父类的静态成员,子类的静态成员,父类的成员变量和构造方法,子类的成员变量和构造方法.当再用这个类生成对象的时候,静态的部份就不再被调用了.因为静态是类的所有实例所共享的,所以它在整个虚拟机的生命周期内只执行一次.

如果我们加上一个t.testClassForName("test1.B");放在main函数的最后面,我们会发现输出还是和刚刚一样,没有任何改变,这个时候,我们知道,当我们调用Class.forName(name);的时候,类是不会自动初始化的,它默认只是把这个类的字节码读入内存,但是并没有初始化这个类.只有我们调用了newInstance()的时候,它才会被初始化.在这里我们再这样试一下:把A和B生成的class文件去掉,然后再分别调用Class.forName和new B(),看看会怎么样,我们会发现当我们调用Class.forName的时候,当我们要for的Name找不到的时候,只会抛出ClassNotFoundException,注意,它只是一个异常而已,而当我们new B()的时候,B的class文件却被我们删掉了,那就事大了,那就将抛出NoClassDefFoundError,呵呵,它就是一个Error了,这点区别我们可要注意啦,当我们在做这些事情的时候,一个只要捕获异常就可以了,一个却需要捕获一个Error,一般来说,Error级别的错误是不希望程序员去捕获的.了解了类的基本加载顺序以及加载机制后,对我们了解JAVA是有一定的帮助的.好了,先讲这些吧,有关类的加载机制以后再继续分享:)

JAVA6.0操作脚本语言
JDK6.0里面加了一个很实用的包,javax.script,它是JAVA新增的操作脚本的包,利用它我们可以对脚本语言进行操作,比如修改,或者调用,并且可以和JAVA语言交互,如果我们利用好的话,我们利用它来实现一些经常要改的部份,这样我们就可以把一些算法写到js文件里面,然后再在运行的时候读取出来并执行,这样就省去了更改一些东西需要重新编译的过程了.

下面我们就来看一个例子吧,看看如何在JAVA代码里面操作脚本并调用里面的方法.
/*
 * Test.java
 * 
 * Created on 2007-9-19, 15:28:49
 * 
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package lbf.script;

import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import javax.script.Bindings;
import javax.script.Invocable;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.swing.JFrame;

/**
 *
 * @author hadeslee
 */
public class Test {

    public static void main(String[] args)throws Exception {
        //根据js的后缀名生成一个解析JS的脚本解析引擎
        ScriptEngine engin=new ScriptEngineManager().getEngineByExtension("js");
        //查询一下这个引擎是否实现了下面很实用的接口
        System.out.println(engin instanceof Invocable);
        //声明两个对象,传入到JS里面去
        JFrame jf=new JFrame("test");
        List<String> list=new ArrayList<String>();
        //得到挷定的键值对象,把当前的两个JAVA对象放进去
        Bindings bind=engin.createBindings();
        bind.put("jf",jf);
        bind.put("list",list);
        //把挷下的键值对象放进去,作用域是当前引擎的范围 
        engin.setBindings(bind, ScriptContext.ENGINE_SCOPE);
        //用引擎执行一段写在JS文件里面的代码
        Object obj=engin.eval(new FileReader("test.js"));
        //这个时候返回值当然 是null了
        System.out.println(obj);
        //把当前的引擎强制转为Invocable,这样就可以调用定义在JS文件里面的一个一个函数了
        Invocable in=(Invocable)engin;
        //得到了从JS里面返回来的对象
        List<String> l=(List<String>)in.invokeFunction("getNames");
        System.out.println(l);
        //调用一下定义在JS里面的另一个函数
        in.invokeFunction("testJS");
        //最后调用一个函数,该函数可以使我们前面定义的窗体显示出来
        in.invokeFunction("doSth");
    }
}

下面是定义在test.js里面的内容
function doSth(){
        jf.setSize(500,300);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);
    }

    function getNames(){
            list.add("doSth");
            list.add("getNames");
            return list;
        }

        function testJS(){
                print('Hello world!');
            }

我们可以看到,在JAVA运行了以后,窗体会显示出来,并且我们可以接收到从JS解析引擎里面传回的数据,当然我们也可以调用一个很普通的JS函数,想象一下,如果我们把我们程序运行时的一些对象都设到Bindings里面去,那么我们JS岂不是有很大的自由度了吗?因为JS里面也可以操作我们的JAVA对象了,并且我们可以像JAVA编程一样的对JS编程了,还不用再编译,马上就可以运行.灵活性岂不是变得更高了吗?

过几天写一个利用JAVA解析JS提高编程灵活性的例子,以体现一下这个包的用处,不过,JS的缺点就是执行速度慢,比起JAVA代码那是慢多了,但是一些初始化的事情,或者一些设置的事情,我们就不用写死在程序里面了,就可以从我们定义的JS文件里面读取了,毕竟那些只执行一次的方法牺牲一点效率换来很高的灵活度是很值得的.

Java 如何判断String为空？
str==null   ||   str.equals(""))    (注意顺序)
  再澄清一个概念：  
  如果str==null说明str还未定义内容。此时，谈不上是否为空。  
  str=""，说明str是个空字符串。只不过长度为0。
------------------------------------------------------------------------------------------------------
String   s;  
  ...  
  if(s==null)  
  {  
    //为null;  
  }  
  if   (s.equals(""))  
  {  
  //为空字符串;  
  }  
  if   (s.length()==0)  
  {  
  //为空字符串;  
  }  
  ==是用来判断对象句柄地址的。说明s还未定义内容。此时，谈不上是否为空。     
  equal是用来判断句柄内容的。  
  想要实现equal的效果可以使用这样  
  s.intern=="".intern