国产在线导航,青青草视频免费在线观看,欧美精品在线一区二区三区

�c�d��信息-Thinking in java��M��W�记

Sun, 29 Nov 2009 11:23:00 GMT

Class.forName("Gum");

forName是取得Class引用的一�U�方法，�q�回一个Class对象的引用�?/p>

如果Gum�c�还没有被加载就加蝲它，在加载过�E�中�Q�Gum的静态子句被执行�?/p>

可能产生的异常：ClassNotFoundException

Class.getInterfaces("Gum")

�q�回对象是Class�c�d��Q�表�C�类Gum包含的接�?/p>

如类Gum implements interface1,

则会获取到interface1的类对象

Class.newInstance()

实现“虚拟构造器”的一�U�途径

�c�d��面常�?/strong>

obj.Class生成对Class对象的引用，它比forName更加安全�Q�因为它在编译时��接受检查�?/p>
注意:当��?Class来创建Class对象的引用时�Q�不会自动初始化Class对象�?/p>
class Initable{
    static final int staticFinal=47;
    static final int staticFinal2=ClassInitialization.rand.nextInt(1000);
    static{
        System.out.println("Initialzing Initable");
    }
}
class Initable2{
    static int staticNonFinal=147;
    static{
        System.out.println("Initialzing Initable2");
    }
}
class Initable3{
    static int staticNonFinal=74;
    static{
        System.out.println("Initialzing Initable3");
    }
}
public class ClassInitialization {
    public static Random rand=new Random(47);
    public static void main(String[] args){
        Class initable=Initable.class;
        System.out.println("After creating Initable ref");
        System.out.println(Initable.staticFinal);
        System.out.println(Initable.staticFinal2);
        System.out.println(Initable2.staticNonFinal);
        Class initable3=Class.forName("Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
    }
}

输出�l�果为：

Initialzing Initable
After creating Initable ref
47
258
Initialzing Initable2
147
Initialzing Initable3
After creating Initable3 ref
74

�l�论�Q?/strong>如果一个static final值是"�~�译期常�?�Q�就象Initable.staticFinal那样�Q�那么这个��g��需要对Initable�c�d��使化��可以读取，但是如果只是��一个域讄��为static和final的，如对Initable.staticFinal2的访问将�q�行强制的初使化�Q�因为它不是一个编译型帔R��?/p>
如果一个static而不是final的，那么在它讉K��Ӟ��L��要求�q�行链接�Q��ؓ�q�个域分配存储空��_��和初始化�Q�初始化该存储空��_��Q�就像对Initable2.staticNonFinal那样�?/p>
泛化的Class引用

Class iniClass=int.class

新的转型语法

case()

InstanceOf

反射

getMethods()�q�回Method对象的数�l?/p>
getConstructors()�q�回Contructor对象的数�l?/p>
动态代�?/strong>

实现InvocationHandler接口

public Object invoke(Objct proxy,Method method,Object[] args)throws Throwable｛｝�Ҏ��

通过Proxy.newProxyInstance(ClassLoader,Class[],InvocationHandler)创徏动态代�?/p>
具体�C�Z��参见:

http://www.aygfsteel.com/aoneany/articles/271019.html

沙漠中的�?/a> 2009-11-29 19:23 发表评论

字符�?Thinking in Java��M��W�记

Sat, 28 Nov 2009 05:54:00 GMT

String对象是不可变�?/p>
Scanner扫描字符串对象�?/p>
备注�Q?/p>
在java�~�译好的class文�g�?有个区域�U�CؓConstant Pool,他是一个由数组�l�成的表,�c�d��
为cp_info constant_pool[],用来存储�E�序中��用的各种帔R��,包括Class/String/Integer�{�各
�U�基本Java数据�c�d��,详情参见The Java Virtual Machine Specification 4.4章节.

对于Constant Pool,表的基本通用�l�构�?
cp_info {
        u1 tag;
        u1 info[];
}

tag是一个数�?用来表示存储的常量的�c�d��,例如8表示String�c�d��,5表示Long�c�d��,info[]�Ҏ��
�c�d��码tag的不同会发生相应变化.
对于String�c�d��,表的�l�构�?
CONSTANT_String_info {
        u1 tag;
        u2 string_index;
}
tag固定�?,string_index是字�W�串内容信息,�c�d��?
CONSTANT_Utf8_info {
        u1 tag;
        u2 length;
        u1 bytes[length];
}
tag固定�?,length为字�W�串的长�?bytes[length]为字�W�串的内�?

代码样例
(以下代码在jdk6中编�?
��Z��详细理解Constant Pool的结�?我们参看一些代�?
    String s1 = "sss111";
    String s2 = "sss222";
    System.out.println(s1 + " " + s2);
�׃��"sss111"�?/span>"sss222"都是字符串常�?在编译期��已�l�创建好了存储在class文�g�?
在编译后的class文�g中会存在�q?个常量的对应表示:
08 00 11 01 00 06 73 73 73 31 31 31 08 00 13 01 ; ......sss111....
00 06 73 73 73 32 32 32                         ; ..sss222

�Ҏ��上面说的String帔R��l�构,我们分析一�?br /> 开始的08为CONSTANT_String_info�l�构中的tag,�?1应该是它的相对引�?01�?br /> CONSTANT_Utf8_info的tag,06为对应字�W�串的长�?73 73 73 31 31 31为字�W�串�?br /> 应的�~�码,接着分析,会发现后面的是对�?/span>"sss222"的存储结�?

�l�过上面分析,我们知道�?1�?3是两个字�W�串的相对引�?��可以修改class文�g
来修�Ҏ��印的内容,把class文�g中的
00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 12 4D
�Ҏ��
00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 10 4D
�E�序��׃��输出sss111 sss111,而不是和原程序一栯��出sss111 sss222,因�ؓ�?br /> 们把�?/span>"sss222"的相对引�?2�Ҏ��了对"sss111"的相对引�?0.

------------分割�U?br /> public class Test {
    public static void main(String[] args) {
        String s1 = "sss111";
        String s2 = "sss111";
    }
}

在上面程序中存在2个相同的帔R��"sss111",对于n个值相同的String帔R��,在Constant Pool�?br /> 只会创徏一�?所以在�~�译好的class文�g�?我们只能扑ֈ�一个对"sss111"的表�C?
000000abh: 08 00 11 01 00 06 73 73 73 31 31 31             ; ......sss111

在程序执行的时�?Constant Pool会储存在Method Area,而不是heap�?

另外,对于""内容为空的字�W�串帔R��,会创��Z��个长度�ؓ0,内容为空的字�W�串攑ֈ�Constant Pool�?
而且Constant Pool在运行期是可以动态扩展的.

关于String�cȝ��说明

1.String使用private final char value[]来实现字�W�串的存�?也就是说String对象创徏之后,��׃��?br /> 再修�Ҏ��对象中存储的字符串内�?��是因�ؓ如此,才说String�c�d��是不可变�?immutable).

2.String�c�L��一个特�D�的创徏�Ҏ��,��是使用""双引��h��创徏.例如new String("i am")实际创徏�?�?br /> String对象,一个是"i am"通过""双引号创建的,另一个是通过new创徏�?只不�q�他们创建的时期不同,
一个是�~�译�?一个是�q�行�?/span>!

3.java对String�c�d��重蝲�?/span>+操作�W?可以直接使用+对两个字�W�串�q�行�q�接.

4.�q�行期调用String�cȝ��intern()�Ҏ��可以向String Pool中动态添加对�?

String的创建方�?/strong>

一般有如下几种
1.直接使用""引号创徏.
2.使用new String()创徏.
3.使用new String("someString")创徏以及其他的一些重载构造函数创�?
4.使用重蝲的字�W�串�q�接操作�W?/span>+创徏.

面试�?

String s1 = new String("s1") ;
String s2 = new String("s1") ;
上面创徏了几个String对象?
�{�案:3�?,�~�译期Constant Pool中创�?�?�q�行期heap中创�?�?

沙漠中的�?/a> 2009-11-28 13:54 发表评论

注释-thinking in java(��M��W�记)

Mon, 23 Nov 2009 16:01:00 GMT

注释为特�D�的interface�c�d��Q�他以interface前面加一个@�W�号�Q�他可以定义在�Q何地方（�c�，属性，�Ҏ��Q?/p>
@Target(ElementType.TYPE)�Q�可选）
@interface ClassInfo {
    String created() default "Jan 31 2005";
    String createdBy();
    String lastModified();
    String lastModifiedBy();
    Revision revision();
}
ElementType.TYPE描绘支持的范�?br /> ANNOTATION_TYPE, CONSTRUCTOR, METHOD, FIELD, LOCAL_VARIABLE, PARAMETER, PACKAGE, and TYPE
他支持定义默认�?br /> 它可以有0个元�?/p>
@ClassInfo (
    created = "Jan 31 2005",
    createdBy = "James Gosling",
    lastModified = "Jan 31 2005",
    lastModifiedBy = "James Gosling",
    revision = @Revision
)
public class Foo {
    // ...
}

沙漠中的�?/a> 2009-11-24 00:01 发表评论

初��化和清除-thinking in java��M��W�记

Sun, 22 Nov 2009 11:08:00 GMT

finalize()

工作原理应该是这��L��Q�一旦垃圾收集器准备好释攑֯�象占用的存储�I�间�Q�它首先调用finalize()�Q�而且只有在下一�ơ垃圾收集过�E�中�Q�才会真正回收对象的内存�?/p>
��Z��么要使用finalize()�Ҏ��

因�ؓjava内存回收之能回收自己java自己创徏的对象，而对调用未java的对象，如C,C++创徏的对象，不能自动的清除，可以通过在finalize()�Ҏ��Q�将�q�些对象昄��的清除�?/p>
finalize()最有用处的地方之一是观察垃圾收集的�q�程�?/p>
class Chair {
  static boolean gcrun = false;
  static boolean f = false;
  static int created = 0;
  static int finalized = 0;
  int i;
  Chair() {
    i = ++created;
    if(created == 47)
      System.out.println("Created 47");
  }
  protected void finalize() {
    if(!gcrun) {
      gcrun = true;
      System.out.println(
        "Beginning to finalize after " +
        created + " Chairs have been created");
    }
    if(i == 47) {
      System.out.println(
        "Finalizing Chair #47, " +
        "Setting flag to stop Chair creation");
      f = true;
    }
    finalized++;
    if(finalized >= created)
      System.out.println(
        "All " + finalized + " finalized");
  }
}

public class Garbage {
  public static void main(String[] args) {
    if(args.length == 0) {
      System.err.println("Usage: \n" +
        "java Garbage before\n  or:\n" +
        "java Garbage after");
      return;
    }
    while(!Chair.f) {
      new Chair();
      new String("To take up space");
    }
    System.out.println(
      "After all Chairs have been created:\n" +
      "total created = " + Chair.created +
      ", total finalized = " + Chair.finalized);
    if(args[0].equals("before")) {
      System.out.println("gc():");
      System.gc();
      System.out.println("runFinalization():");
      System.runFinalization();
    }
    System.out.println("bye!");
    if(args[0].equals("after"))
      System.runFinalizersOnExit(true);
  }
} ///:~

输入�l�果为：

Created 47 Beginning to finalize after 8694 Chairs have been created Finalizing Chair #47, Setting flag to stop Chair creation After all Chairs have been created: total created = 9834, total finalized = 108 bye!

成员初��?/strong>

可以�Ҏ��赋值初使化成员

下面�q�样做是合法的：

class CInit {
int i = f();
int j = g(i);
//...
}

但下面这样做是非法的�Q?br />
class CInit {
int j = g(i);
int i = f();
//...
}

构造器初��?/strong>

class Counter {
int i;
Counter() { i = 7; }

i首先会初始化成零�Q�然后变�?�?/pre>
1.初��化顺�?/strong>

先初使化成员�Q�然后执行构造器内容

2.静态数据初使化

public class Dog {
    public static Dog sDog=new Dog("static dog");
    public Dog(String str){
        System.out.println(str);
    }
    public static void main(String[] args){
        Dog dog=new Dog("init");
    }
}

输入出结�?/pre>
static dog
init

(1) �c�d��为Dog的一个对象首�ơ创建时�Q�或者Dog�cȝ��static�Ҏ��Q�static字段首次讉K��Ӟ��Java解释器必��L��到Dog.class�Q�在事先讑֥�的类路径里搜索）�?br /> (2) 扑ֈ�Dog.class后（它会创徏一个Class对象�Q�这��在后面学到�Q�，它的所有static初始化模块都会运行。因此，static初始化仅发生一�ơ——在Class对象首次载入的时候�?br /> (3) 创徏一个new Dog()�Ӟ��Dog对象的构��E�首先会在内存堆�Q�Heap�Q�里��Z��个Dog对象分配��_��多的存储�I�间�?br /> (4) �q�种存储�I�间会清为零�Q�将Dog中的所有基本类型设为它们的默认��|��零用于数字，以及boolean和char的等仯��定）�?br /> (5) �q�行字段定义时发生的所有初始化都会执行�?br /> (6) 执行构徏器�?/p>
3.明确�q�行的静态初始化

class Spoon {
   static int i;
   static {
     i = 47;
   }
}

�q�段代码仅执行一�ơ——首�ơ生成那个类的一个对象时�Q�或者首�ơ访问属于那个类的一个static成员�?/pre>
4.非静态实例的初始�?/strong>

class Mug {
  Mug(int marker) {
    System.out.println("Mug(" + marker + ")");
  }
}

public class Mugs {
  Mug c1;
  {
    c1 = new Mug(1);
    System.out.println("c1 initialized");
  }
  Mugs() {
    System.out.println("Mugs()");
  }
  public static void main(String[] args) {
    System.out.println("Inside main()");
    Mugs x = new Mugs();
  }
}

输入出结�?/pre>
Inside main()
Mug(1)
c1 initialized
Mugs()

沙漠中的�?/a> 2009-11-22 19:08 发表评论

国产在线导航,青青草视频免费在线观看,欧美精品在线一区二区三区

�c�d��信息-Thinking in java��M���W�记

字符�?Thinking in Java��M���W�记

注释-thinking in java(��M���W�记)

初��化和清除-thinking in java��M���W�记

�c�d��信息-Thinking in java��M��W�记

字符�?Thinking in Java��M��W�记

注释-thinking in java(��M��W�记)

初��化和清除-thinking in java��M��W�记