第4章 初始化和清理
        
         1.构造函数
      是与类名字相同的一种特殊函数  
      提供构造函数，可以确保对象的初始化动作一定会被执行
      <构造函数是不会返回任何东西的>
      没有自定义任何构造函数 编译器会调用默认的构造器
      如果定义了构造器(有或者无参数) 编译器就不会为你分配构造器
       
         2.关键字this
      仅用于函数之内 能够唤起此函数所在的那个类的引用
      以下引用Sun的JLS关于this关键字的说明：

      The keyword this may be used only in the body of an instance method,
      instance initializer or constructor, or in the initializer of an instance variable of a class.
      If it appears anywhere else, a compile-time error occurs.        
     
      When used as a primary expression, the keyword this denotes a value that is a reference
      to the object for which the instance method was invoked ,
      or to the object being constructed. The type of this is the class C within which the keyword this occurs.
      At run time, the class of the actual object referred to may be the class C or any subclass of C.

      翻译一下就是：
      <E文太烂>
      关键字this应该仅仅被用在实例化方法，实例初始化(??)或者构造器，又或者在类的实例化变量的初始化时(??)<像是下面Flower(String s, int petals)构造器中s的赋值??>

    如果它出现在其他地方，将会在编译时发生错误.
     
      当被使用在主表达式时，关键字this表示的是一个指向在实例化方法中调用的类或者是正在被构造的类的引用.
      This在关键字发生类C的内部.在运行的时候，事实上指向的是类C或者类C的子类 .

    一段来自Think in java 2中有关构造函数以及this的代码：

 1   public   class  Flower  {
 2       
 3           int  petalCount  =   0 ;
 4          String s  =   new  String( " null " );
 5          
 6          Flower( int  petals)
 7            {
 8              petalCount  =  petals;
 9              System.out.println( " Constructor w/ int arg only, petalCount=  " +  petalCount);
10            }
11            
12         Flower(String ss) 
13          {
14             System.out.println( " Constructor w/ String arg only, s= "   +  ss);
15             s  =  ss;
16         }
17         
18         Flower(String s,  int  petals) 
19          {
20             this (petals); 
21           // this(s);  //  Can't call two!
22            this .s  =  s;  //  Another use of "this"
23            System.out.println( " String & int args " );
24         }
25         
26        Flower() 
27         {
28             this ( " hi " ,  47 );
29            System.out.println( " default constructor (no args) " );
30        }
31        
32       void  print() 
33       {
34         // !    this(11);  //  Not inside non-constructor!
35        System.out.println(  " petalCount =  "   +  petalCount  +   "  s =  " +  s);
36      }
37      
38    public   static   void  main(String[] args) 
39       {
40         Flower x  =   new  Flower();
41         x.print();
42      }  
43   
44   
45 }  

Constructor w /   int  arg only, petalCount =   47
String  &   int  args
default  constructor (no args)
petalCount  =   47  s  =  hi

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

class  Card  {
  Tag t1  =   new  Tag( 1 );  //  Before constructor
  Card()  {
     //  Indicate we're in the constructor:
    System.out.println( " Card() " );
    t3  =   new  Tag( 33 );  //  Reinitialize t3
  }
  Tag t2  =   new  Tag( 2 );  //  After constructor
   void  f()  {
    System.out.println( " f() " );
  }
  Tag t3  =   new  Tag( 3 );  //  At end
}

public   class  OrderOfInitialization  {
   public   static   void  main(String[] args)  {
    Card t  =   new  Card();   // 程序入手点
    t.f();  //  Shows that construction is done
  }
}  
      

Tag( 1 )
Tag( 2 )
Tag( 3 )
Card()
Tag( 33 )
f()