《Java编程思想第四版》学习笔记--1至4章

第一章 对象导论

1. 万物都是对象

     每个对象都有接口（实现的方法），调用这个接口可以实现某些操作，提供服务。

     用引用去操作一个对象

        例如：String x；

      只是创建了一个引用，并没有创建对象，通过new才能创建一个对象。如果此时想向x发送一个消息，就会返回一个运行时的错误的提示，因为此时x实际上没有与任何事物关联。因此，安全的做法是创建一个引用的同时就对它进行初始化。即：

      String x="xyz";

2.new创建一个对象的存储

        对象放在堆里面。常量通常直接存在程序代码内部。基本类型，在内存中直接存值，在堆栈中。

        寄存器：这是最快的存储区。它位于不同于其他存储区的地方-处理器的内部。但是存储器的数量有限，所以寄存器根据需求分配。不能直接控制，也不能在程序中感觉到寄存器的任何迹象。

        堆栈 ：位于RAM中，但通过堆栈指针可以从处理器那里获得直接支持，堆栈指针若向下移动，则分配新的内存，若向上，则释放那些内存。堆栈指的是栈。

        堆： 一种通用的内存池（也位于RAM区），用于存放所有的java对象，堆不同于堆栈的好处是，编译器不需要知道存储的数据在堆里存货多长时间。因此，在堆里分配有很大的灵活性。 用堆进行存储分配比用堆栈进行存储分配需要更多的时间。

        常量存储：常量值通常直接存储在程序代码内部，这样做是安全的。因为他们永远不会被改变。

        非RAM存储 ：如果数据完全存活于程序之外，那么他可以不受程序的任何控制，在程序中没有运行时也可以存在。其中两个基本的例子是流对象和持久化对象。 在流对象中，对象转化成字节流，通常被发送给另一台机器，在持久化对象中，对象被存放于磁盘上，因此，即使程序终止，他们仍可以保持自己的状态，这种存储方式的技巧在于把对象转化成可以存放在其他媒介上的事物，在需要时，可以恢复成常规的，基于RAM的对象。java提供了对轻量级的持久化支持，JDBC和Hibernate这样的机制提供了更加负责的对数据库中存储和读取的对象信息的支持。
 3.java是单继承

   “是一个”和“像是一个”的关系。

    多态的可互换对象-----向上转型：父类引用指向子类对象。

    简单介绍了容器，异常，并发。

第二章 一切皆是对象

1.基本数据类型

基本类型 大小 包装容器类型 初始化值

boolean  ----      Boolean             false

char        16-bit Character (\u0000)null

byte          8-bit Byte                 (byte)0

short         16-bit  Short            (short)0

  int          32-bit  Integer               0

 long        64-bit  Long                   0L

 float        32-bit  Float                  0.0f

 double     64-bit Double             0.0d

2.不用手动销毁，区别C/C++。垃圾回收机制，垃圾回收器自动清理。不再被引用的对象，自动清理。
3.简单介绍类，方法，类成员。java使用“方法”这个词语来描述子程序，而非C/C++的函数。方法名和参数列表，唯一标识某个方法。方法的基本组成部分包括：名称，参数，返回值和方法体。
4.简单介绍static，属于类，不属于对象。
5.注释，多行注释“/** 内容 */”（文档注释），“/* 内容 */”（只代表注释）和单行注释“//内容”。
6.javadoc命令生成文档。介绍在文档注释中，@author（作者），@version（版本），@see（链接），@param(参数)，@return（返回值）的用法。

第三章 操作符

1.优先级：先乘除再加减。为表达清晰，最好括号括住乘除。
2.“=”等号为赋值。“++”和“--”放变量前面，先加减再赋值；放后面，先赋值再加减。
3.关系操作符“<”，“>”，“<=”，“>=”，“==”，“!=”。
4.比较对象内容用equal()，基本类型可以用==和!=。

==和！=比较的是对象的引用，如果要比较两个对象的实际内容是否相同，必须使用所有对象都适用的特殊方法equals()。但这个方法不适用于基本类型，基本类型直接使用==和！=即可。但equals()方法是Object类的方法，默认的还是比较引用，所以还要在需要比较内容的类中覆盖equals()方法。

Integer n1 = new Integer(47);

Integer n2= new Integer(47);

syso(n1==n2);       false

syso(n1!=n2);        true

syso(n1.equals(n2));     true

尽管对象的内容相同，但是引用是不同的。但是：

Value v1 = new Value();

Value v2 = new Value();

v1.i = v2.i =100;

syso(v1.equals(v2));     false

这是由于equals()的默认行为是比较引用。所以除非在自己的新类中覆盖此方法，否则不能表现出我们想要的行为。

在Object类中，==是对地址的比较，equals()方法是对==的封装，hashcode()方法是本地native方法，使用对象地址计算散列码。所以，两个Object对象的==、equals()和hashcode比较的结果应该是相同的，都是和原始地址相关的计算比较。

String类以及大部分基本类型的包装类都已经对equals()和hashcode()方法进行了覆盖，可直接使用它来比较内容是否相同。

5.逻辑操作符“&&”，“||”，“!”。注意：“&&”操作符的短路，若左边是false，则右边的不再执行。
6.1.39E-43表示：1.39×10的43次方。
7.位操作，“&”，“|”，“^”，“~”。位移操作符“<<”，“>>”。Java中增加了一种“无符号”右移操作符（>>>），它使用“零扩展”：无论正负，都在高位插入0。
8.介绍判断语句：        if-else和 “ ？ : ”。
9.类型转换，窄化操作（将能容纳更多信息的数据类型转换成无法容纳那么多信息的类型），需要强制转换。

向上转型：对于基础数据类型 , 可以自动转型 ,比如: 
int a = 10; 
long b = a; 
这里就是把int型转成了long型 , 因为 long范围比int大 , 这样的转型不会有任何影响 , 所以可以自动转型 。

比如：

A a = new B(); 
其中 A 是B 的父类 , 这也是多态 , 就是父类的对象指向子类的引用 , 你调用a对象 , 实际上是B的类 , 但是B继承A , 拥有A的一切属性和方法。

向下转型：也就是强制转换

long a = 10 ; 
int b = (int) a; 
通过 (int)可以强制转型 , 但是这样会丢失精度 , 比如a如果超过了b的范围 , 那么强转成int型, 只会等于int的最大值 
又比如 : 
B b = new A(); 这样是不行的 , 需要有中间途径 , 比如 
A a = new A(); Object obj = a; B b = (A) a; 
而这种强转 , 又有要求 , 必须是同类型 , 也就是说 A 就是B , 不然会报错。

多余位数直接舍去，不四舍五入，截尾。如“29.7”强转int，变为29。

10.Java中没有sizeof。因为所有数据类型在所有机器中的大小都是相同的。

第四章 控制执行流程

1.true和false。if-else。
2.do-while两种写法：“while(){}”和“do{}while()”。
3.for循环，for(语句1;语句2;语句3){语句4}，“语句3”在“语句4”之后执行。

   for(int i=1,j =i + 10;i<5;i++,j=i*2){

               syso(i---j);

}         // i=1  j=11

             i=2  j=4

            i=3  j=6

            i=4  j=8

这里的for循环里“，”是逗号操作符，“，”更多被用作分隔函数的不同参数，这是唯一用到逗号操作符的地方。
4.foreach（增强for）   for(数据类型     变量名 :被遍历的集合（collection）或者数组)

   return退出方法，break退出循环，continue继续下次循环（执行移回到循环的开头），

switch（条件）{

case  XX ：syso（1）；break；

case  XX ：syso（2）；break；

.......

default ： 0；

   }