第二章 标识符与关键字

1. 标识符

1.1 标识符是什么

一般的，程序员自己有权利命名的单词都是标识符，比如类名，方法名，接口名，常量名等，main方法是java定义好的一个方法名，不可以改变，但也是标识符。

1.2 标识符命名规则和规范

规则1：标识符只能由数字、字母（包括中文）、下划线_、美元符号$组成，不能含有其它符号。
规则2：标识符不能以数字开头
规则3：关键字不能做标识符。例如：public class static void 都是关键字，关键字是不能做标识符的。
规则4：标识符是严格区分大小写的。大写A和小写a不一样。
规则5：标识符理论上是没有长度限制的。
规范1：见名知意（这个标识符在起名的时候，最好一看这个单词就知道啥意思。）
规范2：遵循驼峰命名方式，什么是驼峰（一高一低…）驼峰有利于单词与单词之间很好的进行分隔。
规范3：类名、接口名有特殊要求，类名和接口名首字母大写，后面每个单词首字母大写。
规范4：变量名、方法名有特殊要求，变量名和方法名首字母小写，后面每个单词首字母大写。
规范5：所有“常量”名：全部大写，并且单词和单词之间采用下划线衔接。

规则类似于：现实世界中的法律。 规范类似于：现实世界中的道德。

虽然java中的标识符严格区分大小写 但是对于类名来说，如果一个java源文件中同时出现了：A类和a类 那么谁在前就生成谁。大家以后最好不要让类名“相同”。 最好类名是不同的。

在这需要注意，可以创建名称为123的Java文件，但是不可以在123.java文件中无法定义public的类。

2. 关键字

2.1 关键字是什么

  1.   - 在SUN公司开发Java语言的时候，提前定义好了一些具有特殊含义的单词，这些单词全部小写，具有特殊含义，不能用作标识符。
  2.   - 注意：

java语言中的所有关键字都是全部小写，java语言中是严格区分大小写的，public和Public不一 样。

图片.png

true，false不是关键字，但是也不可以用作标识符

第三章 变量


1. 字面量

1.1 字面量是什么

字面量就是数据，10，1.23，true，false，’a’，”abc”；以上这些都是数据，在程序中都被叫做“字面量”。字面量可以分为很多种类：
整数型字面量：1 2 3 100 -100 -20 ….
浮点型字面量：1.3 1.2 3.14…..
布尔型字面量：true、false没有其它值了，表示真和假,true表示真，false表示假
字符型字面量：’a’、’b’、’中’
字符串型字面量：”abc”、”a”、”b”、”中国”

  1. 注意：
  2.         所有的字符型只能使用单引号括起来。
  3.         所有的字符串型只能使用双引号括起来。

1.2 变量是什么

如果只有字面量，没有变量机制的话，有什么问题？

10 是一个整数型数据，在内存中占有一定的空间（CPU 内存 硬盘），10 + 20 = 30在内存中找一块空间存储10，再找一块空间存储20，CPU负责“+”运算，算完之后的结果是30，那么这个30也会在内存当中找一块临时的空间存储起来。

思考：

以下的三个10在内存当中是一块空间，还是三块不同的空间呢？

  1. public class VarTest{
  3.     public static void main(String[] args){
  5.         System.out.println(10);
  6.         System.out.println(10);
  7.         System.out.println(10); 
  8.         //以上虽然都是10，但是这3个10占用三块不同的内存空间。
  9.     }
  10. }

所以“字面量”机制的话，是远远不够的，因为只有字面量内存是无法重复利用的，这时便引入一个变量。

  1. public class VarTest2{
  3.     public static void main(String[] args){
  5.         int number = 10;
  6.         System.out.println(number);//使用变量之后，内存空间就得到了复用
  7.         System.out.println(number);
  8.         System.out.println(number); 
  9.     }
  10. }
  1.   - 变量其实就是内存当中存储数据的最基本的单元。
  2.   - 对于一个变量来说，包括三要素：变量的数据类型、变量的名字、变量中保存的值

数据类型有什么用呢？
不同的数据类型，在内存中分配的空间大小不同,java虚拟机到底给这个数据分配多大的空间， 主要还是看这个变量的数据类型。

  1.   - 在java语言中有一个规定，变量必须先声明，再赋值才能访问。（没有值相当于这个空间没有开辟；但是成员变量可以不用自己赋值，会有一个默认值，本质上都是赋值了）
  2.   - 可以在一行上声明多个变量：

int a, b, c = 100; //需注意c变量赋值100，a,b变量只声明了没有赋值。

  1.   - 变量的分类

在方法体当中声明的变量叫做局部变量。
注意：局部变量只在方法体当中有效，方法体执行结束该变量的内存就释放了。
在方法体外以及类体内声明的变量叫做成员变量。

  1.   - 变量的作用域：出了大括号就不认识了。

变量可以重新赋值，但在同一个域当中，不能重复声明。当定义了一个int类型的age，在这个 作用域内，就不可以再定义一个age，其他类型的也不可以。

测试：

int name = 张三；这条语句会报错吗，报啥错？？
会报错，如果不仔细看，我们一定会以为是类型不兼容错误，但我们需要注意的是，张三是一个标识符，但是这个标识符并没有声明。

第四章 数据类型

1. 数据类型分类

1.1 基本数据类型

基本数据类型又可以划分为4大类8小种：
第一类：
整数型byte,short,int,long （没有小数的）
第二类：
浮点型 float,double （带有小数的）
第三类：
布尔型boolean：只有两个值true和false，true表示真，false表示假
第四类：
字符型char：java中规定字符型字面量必须使用单引号括起来。属于文字。

1.2 引用数据类型

我们现阶段看到的字符串型String属于引用数据类型，java中除了基本数据类型之外，剩下的都是引用数据类型；其它的我们后续会进一步的学习。

2. 8个基本数据类型所占空间大小

类型 占用字节数量(byte)
———————————————————————————————-
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1 (1byte的1或0，00000001(true)或00000000(false))
char 2

关于boolean类型所占字节大小，网上也有许多的说法，大家可以参考一下

3. 整型

3.1 整型的取值范围

我们就以byte作为参考，byte是 [-128 ~ 127] 共可以标识256个不同的数字。
byte类型的最大值是怎么计算出来的？
byte是1个字节，是8个比特位，所以byte可以存储的最大值是：01111111

  1.                         注意：<br />在计算机当中，一个二进制位最左边的是符号位，当为0时表示正数，当为1时表示负数。所以         byte类型最大值是：01111111<br />                           最大值：10000000（前边是一个二进制） - 1，所以byte类型最大值是：2的7次方 - 1.

这几个取值范围需要记忆一下：
byte: [-128 ~ 127]
short:[-32768 ~ 32767] 可以表示65536个不同的数字
int: [-2147483648 ~ 2147483647]
char: [0~65535] 可以表示65536个不同的数字

short和char实际上容量相同，不过char可以表示更大的数字。 因为char表示的是文字，文件没有正负之分，所以char可以表示更大的数字。

3.2 整数型字面量4种表示形式

  1. public class IntTest01{
  2.     public static void main(String[] args){
  3.         // 十进制
  4.         int a = 10; 
  5.         System.out.println(a); // 10
  7.         // 八进制
  8.         int b = 010;
  9.         System.out.println(b); // 8
  11.         // 十六进制
  12.         int c = 0x10;
  13.         System.out.println(c); // 16
  15.         // 二进制（JDK8的新特性，低版本不支持。）
  16.         int d = 0b10;
  17.         System.out.println(d); // 2
  18.     }
  19. }

4. 字符编码

4.1 字符编码概述及作用

  1.         - 对于8种基本数据类型来说，byte,short,int,long,float,double,boolean，这7种类型计算机表示起来比较容易，因为他们都是数字。其中布尔类型只有两个值true和false，对于char类型来说计算机表示起来比较麻烦，因为char对应的是文字，每一个国家的文字不一样，文字不能直接通过“自然算法”转换成二进制，字符编码诞生了。
  2.         - 字符编码是人为的定义的一套转换表，字符编码其实本质上就是一本字典，该字段中描述了文字与二进制之间的对照关系。

字符编码涉及到编码和解码两个过程，编码和解码的时候必须采用同一套字符编码方式，不然就会出现乱码。 关于字符编码的发展过程？ 起初的时候计算机是不支持文字的，只支持科学计算。实际上计算机起初是为了 战争而开发的，计算导弹的轨道….

  1.   后来随着计算机的发展，计算机开始支持文字，最先支持的文字是英文，英文
  2.   对应的字符编码方式是：ASCII码。
  4.   ASCII码采用1byte进行存储，因为英文字母是26个。（键盘上所有的键全部算上也
  5.   超不过256个。1byte可以表示256种不同的情况。所以英文本身在计算机方面就占有
  6.   优势。）
  7. 'a' --(采用ASCII码进行编码)-> 01100001
  8. 01100001 --(采用ASCII码进行解码)-> 'a'
  9. 如果编码和解码采用的不是同一个编码方式，会出现乱码。
  11. 'a' ---> 97
  13. 'A' ---> 65
  15. ...
  19. '0' ---> 48  （这个'0'不是那个0，是文字'0'）
  21. '1' ---> 49
  25.   随着计算机语言的发展，后来国际标准组织制定了ISO-8859-1编码方式，
  27.   又称为latin-1编码方式，向上兼容ASCII码。但不支持中文。
  31.   后来发展到亚洲，才支持中文，日文，韩文....
  33.   中文这块的编码方式：GB2312<GBK<GB18030 （容量的关系）
  35.   以上编码方式是简体中文。
  39.   繁体中文：big5（台湾使用的是大五码。）
  43.   在java中，java语言为了支持全球所有的文字，采用了一种字符编码方式
  45.   叫做unicode编码。unicode编码统一了全球所有的文字，支持所有文字。
  47.   具体的实现包括：UTF-8 UTF-16 UTF-32....

需要记住：

  1.   ASCII（'a'是97 'A'是65 '0'是48...）
  3.   ISO-8859-1（latin-1）
  5.   GB2312
  7.   GBK
  9.   GB18030
  11.   Big5
  13.   unicode（utf8 utf16 utf32）

5. 字符型

char采用unicode编码方式。

  1. public class CharTest01{
  3.     public static void main(String[] args){
  5.         // 可以的，汉字占用2个字节，java中的char类型占用2个字节，正好。
  6.         char c1 = '中';
  7.         System.out.println(c1);
  9.         char c2 = 'a';
  10.         System.out.println(c2);
  12.         // 0如果加上单引号的话，0就不是数字0了，就是文字0，它是1个字符。
  13.         char c3 = '0';
  14.         System.out.println(c3);
  16.         // 错误: 不兼容的类型: String无法转换为char
  17.         //char c4 = "a";
  19.         // 错误: 未结束的字符文字---->计算机扫描到了a之后，没有扫描到对应的单引号，认为没有结束
  20.         //char c5 = 'ab';
  22.         // 错误: 未结束的字符文字
  23.         //char c6 = '1.08';
  25.     }
  26. }

6. 转义字符

\的出现会将紧挨着的后面的字符进行转义。\碰到t表示tab键。

  1. public class CharTest02{
  2.     public static void main(String[] args){
  4.         char c2 = '\t'; //相当于键盘上的tab键
  6.         // 希望输出的结果是："test"
  7.         // 错误: 需要')'
  8.         //System.out.println(""test"");
  9.         System.out.println("“test”"); //内部的双引号我用中文的行吗？可以。
  10.         System.out.println("\"test\"");
  12.         // 可以的。
  13.         System.out.println("'这样呢'");
  15.         // 反斜杠u表示后面的是一个字符的unicode编码。
  16.         // unicode编码是十六进制的。
  17.         char x = '\u4e2d';
  18.         System.out.println(x); // '中'
  19.     }
  20. }

7. 类型转换

7.1 自动类型转换

  1.   - 在任何情况下，整数型的“字面量/数据”默认被当做int类型处理。
  2.   - 如果希望该“整数型字面量”被当做long类型来处理，需要在“字面量”后面添加L/l，建议添加L。
  3.   - 容量从小到大的排序为：byte < short(char) < int < long < float < double，其中 short和 char都占  用两个字节，但是char 可以表示更大的正整数；
  1. public class IntTest02{
  2.     public static void main(String[] args){
  4.         // 分析：200这个字面量默认被当做int类型来处理
  5.         // b变量是long类型，int类型占4个字节，long类型占8个字节
  6.         // 小容量可以自动转换成大容量，这种操作被称为：自动类型转换。
  7.         long b = 200;
  8.         System.out.println(b);
  10.         // 分析这个是否存在类型转换？
  11.         // 这个不存在类型转换。
  12.         // 在整数型字面量300后面添加一个L之后，300L联合起来就是一个long类型的字面量
  13.         // c变量是long类型，long类型赋值给long类型不存在类型转换。
  14.         long c = 300L;
  15.         System.out.println(c);
  17.         // 题目：
  18.         // 可以吗？存在类型转换吗？
  19.         // 2147483647默认被当做int来处理
  20.         // d变量是long类型，小容量可以自动赋值给大容量，自动类型转换
  21.         long d = 2147483647; // 2147483647是int最大值。
  22.         System.out.println(d);
  24.         // 编译器会报错吗？为什么？
  25.         // 在java中，整数型字面量一上来编译器就会将它看做int类型
  26.         // 而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
  27.         // 记住，不是e放不下2147483648，e是long类型，完全可以容纳2147483648
  28.         // 只不过2147483648本身已经超出了int范围。
  29.         // 错误: 整数太大
  30.         //long e = 2147483648;
  32.         // 怎么解决这个问题呢？
  33.         long e = 2147483648L;
  34.         System.out.println(e);
  36.     }
  37. }

7.2 强制类型转换

大容量不能直接赋值给小容量，需要使用强制类型转换符进行强转。
但需要注意的是：加强制类型转换符之后，虽然编译通过了，但是运行的时候可能会损失精度。

  1. public class IntTest03{
  2.     public static void main(String[] args){
  4.         long x = 100L;
  6. // 大容量转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
  7. // 底层是怎么进行强制类型转换的呢？
  8. // long类型100L：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
  9. // 以上的long类型100L强转为int类型，会自动将“前面”的4个字节砍掉：00000000 00000000 00000000 01100100
  10.         int y = (int)x; // 这个(int)就是强制类型转换符，加上去就能编译通过。
  11.                              // 但是要记住：编译虽然过了，但是运行时可能损失精度。
  12.         System.out.println(y); // 100   在这里可能看不出精度的损失，但是当x的值大于int类型时便会出现
  13.     }
  14. }

7.3 不超范围直接赋值byte、short

  1.      - 当这个整数型字面量没有超出byte的取值范围，则这个整数型字面量可直接赋值给byte类型的变量  
  2.      - 当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short类型的变量
  1. public class IntTest04{
  2.     public static void main(String[] args){
  3.         // 分析：以下代码编译可以通过吗？
  4.         // 300 被默认当做int类型
  5.         // b变量是byte类型
  6.         // 大容量转换成小容量，要想编译通过，必须使用强制类型转换符
  7.         // 错误: 不兼容的类型: 从int转换到byte可能会有损失
  8.         //byte b = 300;
  10.         // 要想让以上的程序编译通过，必须加强制类型转换符
  11.         // 虽然编译通过了，但是可能精度损失。
  12.         // 300这个int类型对应的二进制：00000000 00000000 00000001 00101100
  13.         // byte占用1个字节，砍掉前3个字节，结果是：00101100 (44)
  14.         byte b = (byte)300;
  15.         System.out.println(b); // 44
  17.         // 这个编译能通过吗？
  18.         // 1是int类型，默认被当做int类型来看。
  19.         // x是byte类型，1个字节，大容量无法直接转换成小容量。
  20.         // 当整数型字面量没有超出byte类型取值范围的时候,该字面量可以直接赋值
  21.         byte x = 1;
  22.         byte y = 127;
  24.         // 错误: 不兼容的类型: 从int转换到byte可能会有损失
  25.         byte z = 128;
  27.         // 当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short
  28.         // 类型的变量。
  29.         short s = 1;
  30.         short s1 = 32767;
  31.         // 错误: 不兼容的类型: 从int转换到short可能会有损失
  32.         //short s2 = 32768;
  33.         System.out.println(s);
  34.     }
  35. }