Java深入解析读书笔记(一)

1.　goto,const为java的两个保留关键字，无任何应用语法。因此从不使用。　　

　   goto 使用循环标签:if,break out,here实现goto的功能。

2.　标识符:可由字母数字下划线,$,￥ 组成,首字符不能为数字，不能与关键字相同，不能和字面常量相同。

　　注意:尽量不要使用$，作为标识符。　

3.   关于一些特殊字符的转义:一些字符在java语言规定中有它自己的含义。例如:双引号""为定界符。如果想使用它但并不是作为定界符，就必须转义。

4.　关于字面常量。

　　①　　true,false,null为三个字面常量，而不是关键字。

　　　　　true,false是boolean类型的字面常量。

　　　　　null是引用类型的字面常量。

　　②　　int i = 1;

　　　　　这里的1是整型字面常量，把1分别赋值给给byte，char，short类型的变量，编译是不会出错的。本来java语言规定将int类型的变量赋值给比int类型低的类型

　　　　　必须要进行强制转化的。但是这种情况是个例外。　

public class OneToSCB {
　　//没有任何编译错误
    public static void main(String[] args) {
        byte b = 1;
        char c = 1;
        short s = 1;
        int i = 1;    
        
    }

}

　　　③ 　　对于②中提到的，还有下面的情况

public class OneToSCB {

    public static void main(String[] args) {
        int i = 1;    
        //byte b = i;   //编译不会通过，需要进行强制类型转化
        byte b = (byte)i;  //需要进行强制类型转化才可以通过编译
        
    }

}
        

　　　④ 　　对于②中的特例书上说只适用于变量赋值，对于方法调用是无效的。理由是当你将整型字面常量传递给一个重载的方法，

　　　　　　这个方法重载形参为short和long，如果允许方法调用，则无法判断是扩展为long还是收缩为short。但实际上并不是这样的。　　

public class OneToSCB {
    public static void transformation(){
        char c = 1;
        short s = 1;
        int i = 1;    
        byte b = (byte)i;
    }

    public static void deal(short var){
        System.out.println("deal:int");
    }
    
    public static void deal(long var){
        System.out.println("deal:long");
    }

    public static void deal(byte var){
        System.out.println("deal:byte");
    }
    
    public static void deal(int var) {
        System.out.println("deal:int");    
    }
    
    public static void main(String[] args) {
        OneToSCB.deal(10);
        
    }
}

　　　　上面的方法调用传递的实参10可以准确的匹配到形参为int类型的重载方法。因此控制台打印：deal:int

　　　　当去掉形参为int类型的重载方法时，控制台打印:deal:long 。即把整型字面常量10扩展为long类型，而不是收缩为short类型。

　　　　原因大概也就是编译器为了安全考虑，防止数据的精度损失。

　5。关于编码

　　　　①计算机只认识0和1，但是现实生活中是有很多字符去需要表示的。因此需要把这些字符映射成为计算机可以识别的0和1。

　　　　②ASCII：把英文字符和一些标点符号编码到数字上的编码方法。如：把a编为97，把b编为98。

　　　　　　　　　ASCII只规定了128个数字，因此只能编码128个字符。

　　　　③Unicode：把所有字符和标点都编码到数字上，且为每种语言的每个字符都设定了统一并且唯一的二进制编码。

　　　　　　　　　　例如：把a编为10002，具体的编码方法已被国际标准规定好了。

　　　　　　　　　　　Unicode字符集编码表实例(从知乎上看到的一段解释)：

　　　　　　　　　　　　I　　　　0049　     　　　　　　　　　　　　　　　　　　I　　　　0000 0000 0100 1001

　　　　　　　　　　　　t　　　　0027　　　　对应到计算机中的存储为　　　　　  t　　　　0000 0000 0111 0100

　　　　　　　　　　　　知　　　 77e4　　　　　　　　　　　　　　　　　　　　  知　　　  0111 0111 1110 0101

　　　　　　　　　　　　乎　　    4e4e　　　　　　　　　　　　　　　　　　　　  乎　　　  0100 1110 0100 1110

　　　　　　　　　　　　可看出了Unicode编码对应到计算机中的存储共占16字节，但中英文有明显的区别。英文前9位都为0，但是依然占据存储空间，

　　　　　　　　　　　　产生了浪费，因此就有了后面的UTF-8编码。

　　　④UTF-8:是对Unicode字符集进行编码的一种编码方式。

　　　　编码规则为：单字节的字符。第一位前一位设为1。对于英文文本，UTF-8只占一个字节，与ASCII码相同。

　　　　　　　　　　n个字节的字符(n>1)。第一个字节前n为设为1，第n+1位设为0。第二个字节和后面所有的字节前两位都设为 1 0，

　　　　　　　　　　其余位置按顺序填充字符的Unicode编码。

　　　　　　　　　　即：

　　　　　　　　　　单个字节 　　0xxx xxxx

　　　　　　　　　　2个字节　　  110x xxxx     10xx xxxx

　　　　　　　　　　3个字节　　  1110 xxxx     10xx xxxx 　　10xx xxxx

　　　　　　　　　　四个字节　　 1111 0xxx     10xx xxxx　　 10xx xxxx　　　　10xx xxxx

　　　　则上面采用UTF-8编码为

　　　　　　　　　　　　I　　　　0100 1001

　　　　　　　　　　　　t　　　   0111 0100

　　　　　　　　　　 　 知　　　  1110 0111    1001 1111 　　1010 0101

　　　　　　　　　　　  乎　　　  1110 0100    1011 1001 　　1000 1110

6.增强for循环

　　①　尽量使用增强for循环。但是是有缺陷的。　　

　　　　　　只能顺序访问

　　　　　　一次访问所有元素

　　　　　　无法访问指定元素

　　②  加强for循环底层是通过基本 for 循环实现的。

　　③  加强for循环右侧变量必须为数组或者Iterable类型。因为使用增强for循环操作其他类型时，编译器会把对应的增强for循环写为一下形式

　　for(Iterator it = (Iterator) obj.iterator(); ; ){
            
　　}

　　　　因此如果你不是Iterator类型，就没有iterator方法。就不能使用增强for循环。

　　　　例如一下代码就不能通过编译:因为Map没有实现Iterable接口。

import java.util.List;
import java.util.Map;
class Person{
    
}
public class EnhanceFor {
    public static void main(String[] args){
        Map<String,Person> ps = new HashMap<String,Person>();    
        /*  不能通过编译  
        for(Person p : ps){
            System.out.println(p);
        }
 
        */    
        
    }
}                

　　　　这样对于像Map这样不是Iterable类型的类，如果想要使用增强for循环，可以让这个类去实现Iterable接口，然后实现iterator方法即可。 

7. 　　自增自减运算符

　　　　① 对于"++" 运算符，编译器采用贪心规则:尽量结合更多有效的符号，但是不管是否符合语法规则。

　　　　例如:

public class ZiZeng {
    public static void main(String[] args) {
        int i = 1;
        int i2 = 2;
        int i3 = i+++i2;
        System.out.println(i3);
        
    }
}

　　　　运行结果:

　　　　　　3

　　　　　　

　　　　但是下面这样就不能通过编译：

　　　　　　 int i4 = i--i2;   //本来的目的是 int i4 = i-(-i2);

　　　　② 前置++和后置++的真正区别:不管是前置还是后置都是先将变量的值加1，然后在进行计算。

　　　　　　　　　　　　　　　　　　　真正的区别在于前置++是将变量的值加1后使用增值后的变量进行计算。

　　　　　　　　　　　　　　　　　　　而后置++是先将变量值赋值给临时变量，接下来对变量的值加1，然后使用临时变量的值做运算

　　　　　实例1：int i = 2;

　　　　　　　　  int j = ++i * 30;

　　　　　　　　  编译器的处理如下:

　　　　　　　　　int i = 2;

                          i = i + 1;

　　　　　　　　　int j = i * 30;

　　　　　

　　　　　实例二：int i = 2;

　　　　　　　　　int j = i ++ * 30;

 　　　　　　　　  编译器的处理如下:

　　　　　　　　　int i = 2;

                         int temp = i;

　　　　　　　　　i = i +1;

　　　　　　　　　int j = temp * 30;