【零基础学Java知识梳理超详细版】第二章-变量

【零基础学Java知识梳理超详细版】第二章-变量

2.1 变量基本知识

变量：变量是程序的基本组成单位

变量的三个基本要素：类型 + 名称 + 值

示例：int a = 1 类型 int 名称 a 值 1

如何声明变量：

int a;
a = 100;
int b = 100;
int c = 5, d;

2.2 变量使用注意事项

1. 变量表示内存中的一个存储区域。不同变量，不同类型，占用的空间大小不同。如 int 有 4 byte，而 double 有 8 byte。
2. 该区域有自己的名称 变量名 和类型 数据类型
3. 变量必须先声明，后使用。
4. 变量在同一作用域内不能重名。
5. 该区域的数值可以在同一类型范围内变化。
6. 变量的三个基本要素：类型 + 名称 + 值

2.3 + 号的使用

1. 当左右两边都是数值型，做加法运算
2. 当左右两边任意一方为字符串，做拼接运算
3. 此时运算顺序是从左到右的

System.out.println(1 + 3 + "a" + 6 + 8); // 输出 4a68

2.4 Java数据类型

2.4.1 基本数据类型

• 数值型
  • 整数类型：
    • byte：占用 1 字节
    • short：占用 2 字节
    • int：占用 4 字节
    • long：占用 8 字节
  • 浮点（小数）类型：
    float：占用 4 字节
    double：占用 8 字节
• 字符型
  • char：存放单个字符，占用 2 字节。
• 布尔类型
  • boolean：存放 true，false。占用 1 字节。

2.4.2 引用数据类型

• 类：class，例如String字符串就是一种类
• 接口：interface
• 数组：[ ]

2.5 整数类型

2.5.1 4种类型

用于存放整数值：

• byte 占用 1 字节，范围 -128 ~ 127
• short 占用 2 字节，范围 -215 ~ 215 - 1
• int 占用 4 字节，范围 -231 ~ 231 - 1
• long 占用 8 字节，范围 -263 ~ 263 - 1

2.5.2 使用细节

1. Java 各整数类型有固定的范围和字符长度，不受具体 OS（操作系统）影响，以保证 Java 程序的可移植性。

2. Java 默认整型常量为 int ，要声明 long 型常量必须后加 l 或 L。

3. 从 Java 7 开始，加上前缀 0b 或 0B 就可以写二进制数。

4. 从 Java 7 开始，可以为数字字面添加下划线。这不会影响数字的值，只是为了方便阅读。

   int n = 0b0010;
   n = 0b001;
   n = 100_0_000000;
   n = 0B0000_0010_1100;
   float f = 1.0F;
   

如果基本的整数、浮点类型不能满足范围、精度的需求，可以使用 “大数”BigInteger和BigDecimal，在后续章节中会说明。

2.6 浮点类型

2.6.1 两种类型

可以表示一个小数：

• float 单精度（6 ~ 7 位有效数字），占用 4 字节，范围约 -3.403E38 ~ 3.403E38
• double 双精度（15 位有效数字），占用 8 字节，范围约 -1.798E308 ~ 1.798E308

浮点数在机器中存放形式为：浮点数 = 符号位 + 指数位 + 尾数位

因此，尾数部分可能丢失，造成精度损失。换言之，小数都是近似值。

2.6.2 使用细节

1. 与整数类型相似，有固定的范围和字符长度，不受具体 OS（操作系统）影响。

2. Java 默认浮点常量为 double ，要声明 float 型常量必须后加 ”f“ 或 ”F“

3. 浮点型常量有两种表示形式

   十进制数形式：5.13、315.4F、.414
   
   科学计数法：5.12e2 即 5.12 × 10²、5.12E-2 即 5.12 / 10²

4. 通常情况下，应该使用 double 类型，以其更为精确。

5. 浮点数使用陷阱：当我们对运算结果是小数的进行相对判断时，要小心。（因为小数都是近似值）
   正确方法是：以两个数差值的绝对值，在某个精度范围内判断

   if (Math.abs(num1 - num2) < 0.00001) {
   	System.out.println("差值范围内认为相等");
   }
   

6. 特殊的浮点类型常量

   • 正无穷大：Float.POSITIVE_INFINITY、Double.POSITIVE_INFINITY
     （浮点数运算中）一个正数除以 0，会得到该值
   • 负无穷大：Float.NEGATIVE_INFINITY、Double.NEGATIVE_INFINITY
     （浮点数运算中）一个负数除以 0，会得到该值
   • 0 / 0：Float.NaN、Double.NaN
     （浮点数运算中）0 除以 0，会得到该值
   • 最大、最小值：Float.MAX_VALUE、Double.MIN_VALUE

7. 不能用运算符来比较特殊值，而要用特别的方法

   double num = 0.0 / 0;
   System.out.println(num == Double.NaN);			// <——— 始终为 false。不能如此比较
   System.out.println(Double.isNaN(num));			// <——— 判断是否是 NaN
   num = 1.0 / 0;
   System.out.println(Double.isInfinite(num));		// <——— 是否是无穷大
   

8. 由于不同处理器寄存浮点数的策略可能不同，浮点数运算的结果也可能不同

2.7 字符类型

2.7.1 说明

可以表示单个字符。（可以存放一个数字，因为其字符是数字编号的。输出时会输出数字对应的字符。其中蕴含着编码的概念。）

char c1 = 'a';
char c2 = '\t';
char c3 = '字';
char c4 = 99;

2.7.2 使用细节

1. 字符常量用单引号括起

2. char 的本质是一个整数，输出时，输出的是 unicode 码对应的字符。

   char c1 = 'a';
   System.out.println((int)c1); //用(int)强制类型转换，后面会解读
   

3. char 是可以进行运算的，其相当于一个整数。

   // 注：(int)'a' = 97
   char c1 = 'a' + 1;				// 相当于 char c1 = 'b'
   System.out.println('a' + 1);	// 这个代码输出 98
   System.out.println("a" + 1);	// 这个代码输出 a1
   

4. 字符允许使用转义符

   char c = '\u0041';
   

   转义序列 \u 能出现在引号外。所有这些转义序列会在解析代码前得到处理

   • 以下字符串是空串：

   String s = "\u0022+\u0022";
   

   因为 \u0022 表示引号。该代码等同于以下代码

   String s = "" + "";
   

   • 以下注释会报错：

   // \u000A is a newline
   

   因为 \u000A 是换行符。在解析前会得到处理。在程序看来，上述注释等于以下写法

   // 
   is a newline
   

   • 以下注释也会报错：

   // look inside c:\users
   

   因为程序认为，\users 不是一个合法的转义字符

   • 在某些场合下这种写法似乎也能实现：

   int\u005B\u005D a;			// int[] a; 一个数组
   

2.7.3 字符本质与编码表

• 字符类型的本质，是把字符对应的码值编程二进制，存储。显示时将二进制代码转化为码值，找到对应的字符。

• 字符与码值的对应关系是字符编码表规定的。

  ASCII 编码表，占用 1 byte，共有 128 个字符。（其实可以放256个，但只用了128个位置）
  
  Unicode 编码表，占用 2 byte，字母汉字都占用 2 byte，这样可能浪费空间。0 - 127 的字符与 ASCII相同，所以兼容 ASCII。
  
  UTF-8 编码表，根据不同符号大小可变（1 - 6 byte），字母占用 1 byte，汉字占用 3 byte。是 Unicode的改进，是互联网上使用最广的 Unicode 实现方式。
  
  GBK 编码表，可以表示汉字，字母占用 1 byte，汉字占用 2 byte。
  
  GB2312 编码表，可以表示汉字（GB2312 < GBK）
  
  BIG5 编码表，可以存放繁体中文（香港，台湾）

2.8 布尔类型

2.8.1 说明

boolean 只允许取值 true 或 false ，没有 null。适用于逻辑运算，通常用于程序流程控制 if while do-while for

2.8.2 使用细节

1. 不可以用 0 或 非0 的整数替代 false 或 ture 。这点和 C语言 不同。

2. 不能让布尔类型转换为其他类型。如需转换，请使用如下方法：（此处使用了三元运算符，在下一章会讲）

   boolean b = true;
   int a = b ? 0 : 1;
   

2.9 基本数据类型转换

2.9.1 自动类型转换

2.9.1.1 说明

自动类型转换：Java 在进行赋值或运算时，精度（容量）小的类型自动转换为精度（容量）大的类型。以下两条转换路线：

char --> int --> long --> float --> double

byte --> short --> int --> long --> float --> double

例子：int a = 'c' , double b = 80

2.9.1.2 使用细节

1. 有多种类型数据混合运算时，系统会将所有数据转换成容量最大的那种，再进行运算。

2. 如若把大精度（容量）数据赋值给小精度（容量）类型，就会报错（小数由于精度原因，大赋小会丢失精度，必不可用。但整数大赋小时：1.赋予具体数值时，判断范围。2.变量赋值时，判断类型。反之进行自动类型转换。

3. byte short char 三者不会相互自动转换，但可以计算。计算时首先转化为 int。

   byte a = 1;

byte b = 1;

a + b 的结果是 int 类型

4. boolean 类型不参与自动转换

5. 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。

2.9.2 强制类型转换

2.9.2.1 说明

强制类型转换：自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时加上强制转换符 () ，但可能造成精度降低或溢出，要格外注意。

2.9.2.2 使用细节

1. 当进行数据从大到小转换时，用强制转换。

2. 强制转换只能对最近的操作数有效，往往会使用 ( ) 提升优先级。

   int a = (int)(3 * 2.5 + 1.1 * 6);
   

3. char 可以保留 int 的常量值，但不能保存其变量值。此时需要强制类型转换。

   int a = 10;
   char b = 10;
   char c = (char)a;
   

4. byte short char 在进行运算时，当作 int 处理。

2.9.3 基本数据类型和 String类型的转换

2.9.3.1 说明

1. 基本类型转 String：基本数据类型加上 ""。

   int n1 = 100;
   String s = n1 + "";
   System.out.println(n1 + "" + n1 + "" + n1 + "");
   

2. String 转基本数据类型：通过基本数据类型的包装类调用 parseXXX 方法。

   String s = "100";
   int n1 = Interger parseInt(s); 
   

   特别的，把 String 转换为 char

   char c = s.charAt(0);		// 得到 s 字符串中的第一个字符。
   

2.9.3.2 使用细节

1. 将 String 转成基本数据类型时，要保证其能转换为有效数据。即不能把 "Hello" 转换成 int。
2. 如果格式不正确，会抛出异常，程序会中止。