forName是取得Class引用的一种方法，返回一个Class对象的引用。

如果Gum类还没有被加载就加载它，在加载过程中，Gum的静态子句被执行。

可能产生的异常：ClassNotFoundException

Class.getInterfaces("Gum")

返回对象是Class类型，表示类Gum包含的接口

如类Gum implements interface1,

则会获取到interface1的类对象

Class.newInstance()

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

类字面常量

obj.Class生成对Class对象的引用，它比forName更加安全，因为它在编译时就接受检查。

注意:当使用.Class来创建Class对象的引用时，不会自动初始化Class对象。

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);
    }
}

输出结果为：

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

结论：如果一个static final值是"编译期常量"，就象Initable.staticFinal那样，那么这个值不需要对Initable类初使化就可以读取，但是如果只是将一个域设置为static和final的，如对Initable.staticFinal2的访问将进行强制的初使化，因为它不是一个编译型常量。

如果一个static而不是final的，那么在它访问时，总是要求进行链接（为这个域分配存储空间）和初始化（初始化该存储空间），就像对Initable2.staticNonFinal那样。

泛化的Class引用

Class<Integer> iniClass=int.class

新的转型语法

case()

InstanceOf

反射

getMethods()返回Method对象的数组

getConstructors()返回Contructor对象的数组

动态代理

实现InvocationHandler接口

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

通过Proxy.newProxyInstance(ClassLoader,Class[],InvocationHandler)创建动态代理

具体示例参见:

http://www.blogjava.net/aoneany/articles/271019.html

Scanner扫描字符串对象。

备注：

在java编译好的class文件中,有个区域称为Constant Pool,他是一个由数组组成的表,类型
为cp_info constant_pool[],用来存储程序中使用的各种常量,包括Class/String/Integer等各
种基本Java数据类型,详情参见The Java Virtual Machine Specification 4.4章节.

对于Constant Pool,表的基本通用结构为:
cp_info {
        u1 tag;
        u1 info[];
}

tag是一个数字,用来表示存储的常量的类型,例如8表示String类型,5表示Long类型,info[]根据
类型码tag的不同会发生相应变化.
对于String类型,表的结构为:
CONSTANT_String_info {
        u1 tag;
        u2 string_index;
}
tag固定为8,string_index是字符串内容信息,类型为:
CONSTANT_Utf8_info {
        u1 tag;
        u2 length;
        u1 bytes[length];
}
tag固定为1,length为字符串的长度,bytes[length]为字符串的内容.

代码样例
(以下代码在jdk6中编译)
为了详细理解Constant Pool的结构,我们参看一些代码:
    String s1 = "sss111";
    String s2 = "sss222";
    System.out.println(s1 + " " + s2);
由于"sss111"和"sss222"都是字符串常量,在编译期就已经创建好了存储在class文件中.
在编译后的class文件中会存在这2个常量的对应表示:
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常量结构,我们分析一下
开始的08为CONSTANT_String_info结构中的tag,而11应该是它的相对引用,01为
CONSTANT_Utf8_info的tag,06为对应字符串的长度,73 73 73 31 31 31为字符串对
应的编码,接着分析,会发现后面的是对应"sss222"的存储结构.

经过上面分析,我们知道了11和13是两个字符串的相对引用,就可以修改class文件
来修改打印的内容,把class文件中的
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
程序就会输出sss111 sss111,而不是和原程序一样输出sss111 sss222,因为我
们把对"sss222"的相对引用12改成了对"sss111"的相对引用10.

------------分割线
public class Test {
    public static void main(String[] args) {
        String s1 = "sss111";
        String s2 = "sss111";
    }
}

在上面程序中存在2个相同的常量"sss111",对于n个值相同的String常量,在Constant Pool中
只会创建一个,所以在编译好的class文件中,我们只能找到一个对"sss111"的表示:
000000abh: 08 00 11 01 00 06 73 73 73 31 31 31             ; ......sss111

在程序执行的时候,Constant Pool会储存在Method Area,而不是heap中.

另外,对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到Constant Pool中,
而且Constant Pool在运行期是可以动态扩展的.

关于String类的说明

1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能
再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法

一般有如下几种
1.直接使用""引号创建.
2.使用new String()创建.
3.使用new String("someString")创建以及其他的一些重载构造函数创建.
4.使用重载的字符串连接操作符+创建.

面试题:

String s1 = new String("s1") ;
String s2 = new String("s1") ;
上面创建了几个String对象?
答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.

@Target(ElementType.TYPE)（可选）
@interface ClassInfo {
    String created() default "Jan 31 2005";
    String createdBy();
    String lastModified();
    String lastModifiedBy();
    Revision revision();
}
ElementType.TYPE描绘支持的范围
ANNOTATION_TYPE, CONSTRUCTOR, METHOD, FIELD, LOCAL_VARIABLE, PARAMETER, PACKAGE, and TYPE
他支持定义默认值
它可以有0个元素

@ClassInfo (
    created = "Jan 31 2005",
    createdBy = "James Gosling",
    lastModified = "Jan 31 2005",
    lastModifiedBy = "James Gosling",
    revision = @Revision
)
public class Foo {
    // ...
}

工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。

为什么要使用finalize()方法

因为java内存回收之能回收自己java自己创建的对象，而对调用未java的对象，如C,C++创建的对象，不能自动的清除，可以通过在finalize()方法，将这些对象显示的清除。

finalize()最有用处的地方之一是观察垃圾收集的过程。

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);
  }
} ///:~

输入结果为：

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!

成员初使化

可以方法赋值初使化成员

下面这样做是合法的：



class CInit {

int i = f();

int j = g(i);

//...

}



但下面这样做是非法的：



class CInit {

int j = g(i);

int i = f();

//...

}

构造器初使化

class Counter {

int i;

Counter() { i = 7; }

i首先会初始化成零，然后变成7。

1.初使化顺序

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

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");

    }

}

输入出结果

static dog

init

(1) 类型为Dog的一个对象首次创建时，或者Dog类的static方法／static字段首次访问时，Java解释器必须找到Dog.class（在事先设好的类路径里搜索）。
(2) 找到Dog.class后（它会创建一个Class对象，这将在后面学到），它的所有static初始化模块都会运行。因此，static初始化仅发生一次——在Class对象首次载入的时候。
(3) 创建一个new Dog()时，Dog对象的构建进程首先会在内存堆（Heap）里为一个Dog对象分配足够多的存储空间。
(4) 这种存储空间会清为零，将Dog中的所有基本类型设为它们的默认值（零用于数字，以及boolean和char的等价设定）。
(5) 进行字段定义时发生的所有初始化都会执行。
(6) 执行构建器。

3.明确进行的静态初始化

class Spoon {  

   static int i;  

   static {    

     i = 47;  

   }

}

这段代码仅执行一次——首次生成那个类的一个对象时，或者首次访问属于那个类的一个static成员时

4.非静态实例的初始化

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();

  }

}


输入出结果

Inside main()

Mug(1)

c1 initialized

Mugs()