【Thinking in java】一切都是对象

  尽管Java是基于C++的，但是相比之下，Java是一种更“纯粹”的面向对象程序设计语言。

2.1 用引用操纵对象

       Java的数据类型分为两大类，即基本数据类型和引用数据类型，在基本数据类型中有3类,8种基本数据类型（逻辑型-boolean；文本型-char；数值型-byte、short、int、long、float、double），引用数据类型有类（class）、接口（interface）、数组（array），注意，引用数据类型的大小统一 为 4 个字节，记录的是其引用对象的地址！

1. package chapter02;  
2.   
3. public class Reference {  
4.     String s;  
5.     /*这里创建的s不是一个String对象，而是一个引用。 
6.      * 如果此时向s发送一个消息，就会返回一个运行时错误，因为s实际没有与任何事物相关联的。 
7.      * 安全做法：创建一个引用的同时便进行初始化。 
8.      */  
9.     String s1 = new String();  
10.     String s2 = "string";  
11. }  

2.2 必须由你创建所有对象

       2.2.1 存储到什么地方

1. 寄存器。这是最快的存储区，它位于处理其内部。不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。
2. 堆栈。位于通用RAM（随机访问存储器）中，存储速度仅次于寄存器的存储区。常用于存储基本数据类型和引用对象，但是java对象并不存储于其中。
3. 堆。一种通用的内存池（也位于RAM中），用于存放所有的Java对象。好处：编译器不需要知道要从堆里分配多少存储区域，也不必知道存储的数据在堆里存活多长时间。
4. 静态存储。固定的位置，Java对象本身从来不会存放在静态存储空间里。
5. 常量存储。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。
6. 非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也是可以存在。

       Java提供对轻量级持久化的支持，未来的Java版本可能会为持久化提供更全面的解决方案。

       2.2.2 特例：基本类型

        高精度数字

               BigInteger(任意高精度的整数) 和 BigDecimal（任意高精度的浮点数）

1. package chapter02;  
2.   
3. public class BigNumber {  
4.     /* 
5.     public class BigDecimal extends Number implements Comparable<BigDecimal> 
6.     public class BigInteger extends Number implements Comparable<BigInteger> 
7.     */  
8.     //两个类都是继承Number类并且实现Comparable接口  
9. }  

2.3 永远不需要销毁对象

      大多数过程型语言都有作用域（scope）的概念。作用域决定了在其内定义的变量名的可见性和生命周期。在C、C++、Java中，作用域由花括号的位置决定。

       在作用域内定义的变量只可用于作用域结束之前。

2.4 基本成员默认值 

基本类型	默认值
boolean	false
char	'\u000'(null)
byte	(byte)0
short	(short)0
int	0
long	0L
float	0.0f
double	0.0d

2.5 static关键字

       如果一个类成员被声明为static，它就能够在类的任何对象创建之前被访问，而不必引用任何对象。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量，例如：声明一个static的变量count作为new一个类实例的计数。声明为static的方法有以下几条限制： 
              1、它们仅能调用其他的static 方法。
              2、它们只能访问static数据。
              3、它们不能以任何方式引用this 或super。
       如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。
      static的相关执行顺序和执行次数：

1. package chapter02;  
2. class Test {  
3.     {  
4.         System.out.println("Test before");  
5.     }  
6.     static {  
7.         System.out.println("Test static initialized");  
8.     }  
9.     {  
10.         System.out.println("Test after");  
11.     }  
12. }  
13. public class Static {  
14.   
15.     static int a = 3;  
16.     static int b;  
17.     static void method(int x) {  
18.         System.out.println("x = " + x );  
19.         System.out.println("a = " + a );  
20.         System.out.println("b = " + b );  
21.     }  
22.     {  
23.         System.out.println("Static before");  
24.     }  
25.     static {  
26.         System.out.println("Static block initialized");  
27.     }  
28.     {  
29.         System.out.println("Static after");  
30.     }  
31.     public static void putLine(){  
32.         System.out.println("------------------------------------------");  
33.     }  
34.     public static void main(String[] args) {  
35.         method(12);  
36.         putLine();  
37.           
38.         new Test();  
39.         putLine();  
40.           
41.         new Test();  
42.         putLine();  
43.           
44.         new Static();  
45.         putLine();  
46.           
47.         new Static().method(13);  
48.     }  
49. }  
50. /* 
51. Static block initialized 
52. x = 12 
53. a = 3 
54. b = 0 //静态被自动初始化为0 
55. ------------------------------------------ 
56. Test static initialized 
57. Test before 
58. Test after 
59. ------------------------------------------ 
60. Test before 
61. Test after 
62. ------------------------------------------ 
63. Static before 
64. Static after 
65. ------------------------------------------ 
66. Static before 
67. Static after 
68. x = 13 
69. a = 3 
70. b = 0 
71. */