大数据开发基础入门与项目实战（一）Java SE之2.变量和数据类型

柔情只为你懂 2022-09-05 05:19 2阅读 0赞

### 文章目录 ###

*  前言
 *  1.变量
 *   *  （1）变量的基本概念
     *  （2）变量的声明和使用
     *  （3）变量使用的注意事项
     *  （4）标识符的命名法则
     *  （5）变量输入输出案例和优化
     *  （6）手册的介绍和官方库的使用
 *  2.数据类型
 *   *  （1）数据类型的分类
     *  （2）常用的进制
     *  （3）进制之间的转换
     *   *  Ⅰ 正十进制转为二进制
         *  Ⅱ 正二进制转为十进制
         *  Ⅲ 负十进制转为二进制
         *  Ⅳ 负二进制转为十进制
     *  （4）单个字节表示的整数范围
     *  （5）整数类型
     *  （6）整数类型的编程使用
     *  （7）整型类型笔试考点
     *  （8）浮点类型
     *  （9）浮点类型的编程使用
     *  （10）布尔类型的概念和使用
     *  （11）字符类型的概念和使用
     *  （12）Unicode字符集的概念和使用
     *  （13）转义字符的概念和使用
     *  （14）类型转换的概念和使用
 *  总结

> 本文由[我来 wolai - 不仅仅是未来的云端协作平台与个人笔记][wolai -]提供支持，可点击  
> [https://www.wolai.com/signup?invitation=SWEW7UI][https_www.wolai.com_signup_invitation_SWEW7UI]注册并体验 wolai，或者下载wolai APP或客户端输入邀请码`SWEW7UI` ，这样你和我都可以获得积分哦。wolai是一个有温度的平台，赶紧来注册体验吧。

# 前言 #

本文主要介绍了Java中的变量和数据类型，包括变量（变量的基本概念、变量的声明和使用、标识符的命名法则和手册的介绍和官方库的使用等）和数据类型（数据类型的分类、常用的进制、整数类型、浮点类型、布尔类型、字符类型和类型转换等）。

# 1.变量 #

## （1）变量的基本概念 ##

当需要在程序中记录**单个数据内容** 时，则声明一个变量即可，而声明变量的本质就是**在内存中申请一个存储单元** ，由于该存储单元中的**数据内容可以发生改变** ，因此称为"变量"。

由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在Java语言中使用**数据类型** 加以描述，为了便于下次访问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。

## （2）变量的声明和使用 ##

变量的声明方式为：

数据类型 变量名 = 初始值;

其中=初始值可以省略，但;不可以省略。

新定义VarTest类如下：

/* 变量的声明和使用 */
    
    public class VarTest { 
      
      public static void main(String args[]) { 
        
        // 1.声明int类型类型的变量并初始化
        int age = 18;
        System.out.println("age = " + age);  // +用于将左右两边的内容拼接起来、组成新的字符串
        
      }
    }

输出：

age = 18

其中，11行的`+`是字符连接符，用于将左右两边的内容拼接起来、组成新的字符串。

## （3）变量使用的注意事项 ##

1.  使用变量之前需要声明

Java是强类型语言，变量在使用前必须声明来指明其数据类型，否则会报错`错误: 找不到符号`。

1.  使用变量之前需要初始化

否则可能会报错`错误: 可能尚未初始化变量name` 。

1.  变量不能重复声明

否则会报错`错误: 已在方法 main(String[])中定义了变量 xxx`。

例如：

/* 变量的声明和使用 */
    
    public class VarTest { 
      
      public static void main(String args[]) { 
        
        // 1.声明int类型类型的变量并初始化
        int age = 18;
        System.out.println("age = " + age);  // +是字符连接符，用于将左右两边的内容拼接起来、组成新的字符串
        
        // 2.使用变量的注意事项
        // 2.1 使用变量之前需要声明
        // System.out.println("name = " + name); // 错误: 找不到符号
        // 2.2 使用变量之前需要初始化
        // String name;
        // System.out.println("name = " + name); // 错误: 可能尚未初始化变量name
        // 2.3 变量不能重复声明
        int age = 20;
        System.out.println("age = " + age);      // 错误: 已在方法 main(String[])中定义了变量 age
      }
    }

## （4）标识符的命名法则 ##

*  由数字、字母、下划线和$组成，其中**数字不能开头**

一般选择字母、数字和下划线命名。

*  不能使用Java中的关键字

**关键字** 是Java语言中表示特殊含义的单词，Java中的关键字如下：  
![java关键字][java]

*  **区分大小写** ，长度没有限制但不宜过长

标识符的大小写不同时，表示不同的标识符

*  尽量做到见名知意，支持中文但**不推荐**
 *  标识符范围如下：

- 变量

- 类

- 属性

- 方法

- 包

## （5）变量输入输出案例和优化 ##

> 提示用户从键盘输入自己的姓名和年龄信息并打印出来。

实现思路：

*  声明两个变量用于记录姓名和年龄信息
 *  提示用户输入，并保存到声明的对应变量中
 *  打印变量值

根据实现思路设计代码如下：

/* 变量的输入和输出 */
    
    // 导入java目录下util目录下的Scanner类
    import java.util.Scanner;
    
    public class VarIOTest { 
      
      public static void main(String[] args) { 
        
        // 1.声明变量
        String name;
        int age;
        
        // 2.提示用户输入
        System.out.println("Please input your name and age: ");
        // 创建一个扫描器来扫描键盘输入的内容，System.in代表键盘输入
        Scanner sc = new Scanner(System.in);
        // 通过扫描器读取字符串数据放入变量name中
        name = sc.next();
        // 通过扫描器读取整型数据放入变量age中
        age = sc.nextInt();
        
        // 3.打印变量的数值
        System.out.println("name = " + name);
        System.out.println("age = " + age);
      }
    }

在提示用户输入时，需要从键盘输入中获取数据，此时就需要用到扫描器类Scanner，这是Java中的标准类，通过`import java.util.Scanner;` 导入即可使用。

在编译运行后，输入和输出示意如下：

Please input your name and age:
    Corley 18
    name = Corley
    age = 18

> 需要注意，name和age需要按顺序输入，才能正常读入和打印。

上面的代码还可以进行优化：

*  面的实现思路是先声明变量再输入数据并保存到变量，即先申请了存储空间、后边再使用，可能会造成资源的浪费，此时可以将声明变量和输入赋值合并为一步，使得符合“**变量随使用随声明** ”的原则；
 *  输出时打印了2次，也可以合并为一次，达到尽可能**减少重复代码** 的目标。

优化现有的代码如下：

/* 变量的输入和输出 */
    
    // 导入java目录下util目录下的Scanner类
    import java.util.Scanner;
    
    public class VarIOTest { 
      
      public static void main(String[] args) { 
        
        // 1.声明变量
        // String name;
        // int age;
        
        // 2.提示用户输入
        System.out.println("Please input your name and age: ");
        // 创建一个扫描器来扫描键盘输入的内容，System.in代表键盘输入
        Scanner sc = new Scanner(System.in);
        // 通过扫描器读取字符串数据放入变量name中
        String name = sc.next();
        // 通过扫描器读取整型数据放入变量age中
        int age = sc.nextInt();
        
        // 3.打印变量的数值
        // System.out.println("name = " + name);
        // System.out.println("age = " + age);
        System.out.println("name = " + name + ", age = " + age);
      }
    }

输入和输出如下：

Please input your name and age:
    Corley 18
    name = Corley, age = 18

可以看到，也达到了效果。

## （6）手册的介绍和官方库的使用 ##

前面用到的Scanner属于Java官方库，Java中还有很多其他官方库，即API。

JDK中带有大量的API类，是由Java系统带来的工具库，是Java官方程序员的技术积累使用这些类可以大大简化编程、提高开发效率。

具体的API类的功能和使用，可以查看参考手册。

# 2.数据类型 #

前面已经用到了int和String两种数据类型，其实还有很多数据类型。

## （1）数据类型的分类 ##

Java中的数据类型主要分为两大类：

*  基本数据类型

- byte

- short

- int

- long

- float

- double

- boolean

- char

*  引用数据类型

- 数组

- 类

- 接口

- 枚举

- 标注

## （2）常用的进制 ##

*  常生活中一般采用**十进制** ，逢十进一，权重是 1 0 0 10^0 100、 1 0 1 10^1 101、 1 0 2 10^2 102、……
 *  计算机底层采用0和1组成的**二进制** ，以`0b` 开头表示，逢二进一，权重是 2 0 2^0 20、 2 1 2^1 21、 2 2 2^2 22、……

最高位（最左边）用于代表符号位

- 0表示非负数

- 1表示负数

*  **八进制** 和**十六进制** 是二进制的简写，八进制以`0`开头表示，十六进制以`0x` 表示。

## （3）进制之间的转换 ##

### Ⅰ 正十进制转为二进制 ###

*  除二取余法

以十进制的45为例，转化为二进制的过程如下：

![十进制转二进制除二取余法][5b20992e43a84861a118286f42bde895.png_pic_center]

然后将右边的余数倒序排列，即得到二进制的数`0b101101` ，这其实省略了为0的高位，六十四位机器中可以看到：

![除二取余法序列][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center]

可以看到，64位中的最高位为0、表示正数，从62-6位均为0。

*  拆分法

将十进制的数拆分成二的权重的和。

还是以45为例：

45 = 32 + 8 + 4 + 1 = 2^5 + 2^3 + 2^2 + 2^0

有权重的对应位置位1、没有权重则为0，所以二进制的结果为`0b101101` 。

### Ⅱ 正二进制转为十进制 ###

正二进制转换为十进制与正十进制转为二进制的过程正好相反，采用加权法：

使用二进制中的每一位乘对应位的权重再累加求和。

以`0b101101` 为例如下：

1 ∗ 2 5 + 0 ∗ 2 4 + 1 ∗ 2 3 + 1 ∗ 2 2 + 1 ∗ 2 0 = 32 + 8 + 4 + 1 = 45 1 \* 2^5 + 0 \* 2^4 + 1 \* 2^3 + 1 \* 2^2 + 1 \* 2^0 = 32 + 8 + 4 + 1 = 45 1∗25\+0∗24\+1∗23\+1∗22\+1∗20=32\+8\+4\+1=45

### Ⅲ 负十进制转为二进制 ###

先将十进制的绝对值转为二进制，然后进行按位取反再加1。

以十进制-45为例：

1.  将十进制的45转换为二进制

45转为二进制，为`0b00101101`

1.  按位取反

取反得到`11010010`

1.  加1

相加， 11010010 + 1 = 11010011 11010010 + 1 = 11010011 11010010\+1=11010011，所以结果为`0b11010011` 。

得到结果后可以进行校验，将得到的值与正的二进制相加，看看相加是否为0，如果相加最高位进1、则省去。

### Ⅳ 负二进制转为十进制 ###

过程与负十进制转为二进制过程相反，

以`0b11010011` 为例

*  先减1

得到`0b11010010`

*  按位取反

得到`0b0011101`

*  转为十进制

得到45。

## （4）单个字节表示的整数范围 ##

计算机中，一个字节占8位，其中最高位（第一位）表示符号，所以数值占7位：

*  非负数表示的整数范围为0000 0000 - 0111 1111，即0 - 127
 *  负数表示的整数范围为1000 0000 - 11111111，即-128 - -1

所以单个字节所能表示的整数范围为-128 - 127，即 − 2 7 − 2 7 − 1 -2^7 - 2^7-1 −27−27−1。

## （5）整数类型 ##

Java中描述整数数据的类型有4个：

*  byte

在内存空间中占1个字节，即8位，范围为 − 2 7 − 2 7 − 1 -2^7 - 2^7-1 −27−27−1，即-128 - 127。

*  short

在内存空间中占2个字节，即16位，范围为 − 2 15 − 2 15 − 1 -2^\{15\} - 2^\{15\} - 1 −215−215−1，即-32768 - 32767。

*  int

在内存空间中占4个字节，即32位，范围为 − 2 31 − 2 31 − 1 -2^\{31\} - 2^\{31\} - 1 −231−231−1。

*  long

在内存空间中占8个字节，即64位，范围为 − 2 63 − 2 63 − 1 -2^\{63\} - 2^\{63\} - 1 −263−263−1。

推荐使用int类型，因为int相比于byte、short**范围更大** 、不易超过，相比于long**省内存** 。

## （6）整数类型的编程使用 ##

先进行byte的使用测试：

/* 整数类型的使用 */
    
    public class IntTest { 
      
      public static void main(String[] args) { 
        // 1.声明byte类型并初始化
        byte b1 = 25;
        // 2.打印
        System.out.println("b1 = " + b1);
      }
    }

输出：

b1 = 25

再进行超范围的测试，即使用超过byte范围的值进行计算，如下：

/* 整数类型的使用 */
    
    public class IntTest { 
      
      public static void main(String[] args) { 
        // 1.声明byte类型并初始化，超范围测试
        byte b1 = 250;
        // 2.打印
        System.out.println("b1 = " + b1);
      }
    }

输出：

IntTest.java:9: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                    byte b1 = 250;
                              ^
    1 个错误
    错误: 编译失败

可以看到，因为超过了byte的最大范围127，所以报错。

上面代码中的250这样直接写出的数据称为**直接量** 或常量或字面值，默认为int类型，范围比byte大，此时可以声明short或者更大范围的类型。

short类型测试如下：

输出：

b1 = 25 
    s1 = 250

如果超过short范围，则会报错`错误: 不兼容的类型: 从int转换到short可能会有损失`。

再测试int类型，如下：

/* 整数类型的使用 */
    
    public class IntTest { 
      
      public static void main(String[] args) { 
        // 1.声明byte类型并初始化
        byte b1 = 25;
        // 2.打印
        System.out.println("b1 = " + b1);
        // 3.声明short类型并初始化
        short s1 = 250;
        // 4.打印
        System.out.println("s1 = " + s1);
        // 3.声明int类型并初始化
        int i1 = 250250;
        // 4.打印
        System.out.println("i1 = " + i1);
      }
    }

再测试超出int范围，如下：

/* 整数类型的使用 */
    
    public class IntTest { 
      
      public static void main(String[] args) { 
        // 1.声明byte类型并初始化
        byte b1 = 25;
        // 2.打印
        System.out.println("b1 = " + b1);
        // 3.声明short类型并初始化
        short s1 = 250;
        // 4.打印
        System.out.println("s1 = " + s1);
        // 3.声明int类型并初始化，超范围测试
        int i1 = 250250250250;
        // 4.打印
        System.out.println("i1 = " + i1);
      }
    }

输出：

IntTest.java:17: 错误: 整数太大
                    int i1 = 250250250250;
                             ^
    1 个错误
    错误: 编译失败

因为默认为int类型，此时这个数据已经出错，无法显示。

此时需要进行类型转换，再数值后面加上字母`L` 或`l` 即可，最好使用大写字母，便于与数字`1` 区分开。

即上面可改为`250250250250L` ，此时就会报错`错误: 不兼容的类型: 从long转换到int可能会有损失` 。

long类型测试如下：

/* 整数类型的使用 */
    
    public class IntTest { 
      
      public static void main(String[] args) { 
        // 1.声明byte类型并初始化
        byte b1 = 25;
        // 2.打印
        System.out.println("b1 = " + b1);
        // 3.声明short类型并初始化
        short s1 = 250;
        // 4.打印
        System.out.println("s1 = " + s1);
        // 5.声明int类型并初始化
        int i1 = 250250;
        // 6.打印
        System.out.println("i1 = " + i1);
        // 7.声明long类型并初始化
        long l1 = 250250250250L;
        // 8.打印
        System.out.println("l1 = " + l1);
      }
    }

输出：

b1 = 25
    s1 = 250
    i1 = 250250
    l1 = 250250250250

## （7）整型类型笔试考点 ##

1.  标识符命名规则中，数字为什么不能开头？
    
        如果标识符中可以以数字开头，则可能会有`123` 的变量名，则编译器分不清楚这是一个变量，还是一个直接量，所以Java官方退出这个规定，Java也称为“安全的语言”。
2.  下面的代码是否有错误？若有请指出并说明原因。
    
        int i1 = 25;
        byte b2 = i2;
        System.print.println("b2 = " + b2);
    
    编译运行时，会报错`不兼容的类型: 从int转换到byte可能会有损失` ，因为int型转化为byte型可能有精度的损失，虽然这里的值很小，但是变量的值可能随时改变，如果数值变得很大时，就可能会超出byte类型的范围。

## （8）浮点类型 ##

浮点类型是Java中用于描述小数数据的类型，包括

*  float

内存空间中占4个字节，叫单精度浮点数，可以表示7位有效数字，范围是 − 3.4 ∗ 1 0 38 − 3.4 ∗ 1 0 38 -3.4 \* 10 ^ \{38\} - 3.4 \* 10 ^ \{38\} −3.4∗1038−3.4∗1038。

*  double

内存空间中占8个字节，叫双精度浮点数，可以表示15位有效数字，范围是 − 1.798 ∗ 1 0 308 − 1.798 ∗ 1 0 308 -1.798 \* 10 ^ \{308\} - 1.798 \* 10 ^ \{308\} −1.798∗10308−1.798∗10308。

推荐使用**double** 类型，精度（有效位数）更高，同时多占的字节数也可以忽略不计。

## （9）浮点类型的编程使用 ##

float类型测试如下：

输出：

f1 = 3.14159
    f2 = 3.1415927

如果代码中不加`f` ，即`float f1 = 3.14159f;` ，会报错`不兼容的类型: 从double转换到float可能会有损失` ，这是因为：

小数数据叫直接量，默认是double类型，将double类型的值赋值给float类型时会有所占字节数和有效位数的损失。

还可以关注到，`f2`打印出来和原来赋的值不一样，这是因为float型的有效位数为7、最多只能保留7位小数。

再测试double型，如下：

/* 浮点类型的使用 */
    
    public class DoubleTest { 
      
      public static void main(String[] args) { 
        
        // 1.声明float类型变量并初始化
        float f1 = 3.14159f;
        float f2 = 3.1415926535f;
        // 2.打印变量的值
        System.out.println("f1 = " + f1);
        System.out.println("f2 = " + f2);
        // 3.声明double类型变量并初始化
        double d1 = 3.14159;
        double d2 = 3.1415926535;
        // 4.打印变量的值
        System.out.println("d1 = " + d1);
        System.out.println("d2 = " + d2);
      }
    }

输出：

f1 = 3.14159
    f2 = 3.1415927
    d1 = 3.14159
    d2 = 3.1415926535

可以看到，因为数值在double的有效位数范围内，所以打印出了原数值。

double计算时可能会有误差，若希望实现精确计算则可以使用`java.math.BigDecimal`。

## （10）布尔类型的概念和使用 ##

布尔类型是Java中用于描述真假信息的类型，数值只有`true` 和`false` 。

布尔类型在内存空间中所占大小没有明确规定，可以认为是**1个字节** 。

使用如下：

/* 布尔类型的使用 */
    
    public class BooleanTest{ 
      
      public static void main(String[] args) { 
        
        // 1.声明boolean类型变量并初始化
        boolean b1 = true;
        System.out.println("b1 = " + b1);
        b1 = false;
        System.out.println("b1 = " + b1);
      }
    }

输出：

b1 = true
    b1 = false

其中第12行的`=` 是赋值运算符，即将`=` 右边的值赋值给左边的变量、覆盖变量原来的值。

不能将`true` 和`false` 以外的其他值赋值给boolean类型的变量，否则会报错，例如上面第12行改为`b1 = 25;` 时会报错`不兼容的类型: int无法转换为boolean`。

## （11）字符类型的概念和使用 ##

char类型（字符类型）是Java语言中用于描述单个字符的数据类型，如：‘a’、'中’等。

其中char类型在内存空间中占2个字节并且**没有符号位** ，表示的范围是`0 ~ 65535`。

由于现实生活中很少有数据能够被单个字符描述，因此以后的开发中更多的是使用由多个字符串起来组成的字符串，使用**String类型** 加以描述，如：“hello”、“Corley”等。

计算机的底层只识别0和1组成的二进制序列，char类型的图案数据不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就需要给该数据指定一个编号，然后将编号存储起来即可，该编号即为ASCII。

使用如下：

打印：

c1 = a
    c1字符的对应编号为：97
    c2 = b
    c2字符的对应编号为：98

其中，`(int)c1` 是将char类型的c1强制转化为int类型；

因为计算机底层存储char类型时存储的都是编号，因此也可以直接将整型的值赋值给char型变量。

## （12）Unicode字符集的概念和使用 ##

从上面可以知道，a的ASCII编号是97、b是98，常见的ASCII包括：

*  ‘0’ - 48
 *  ‘A’ - 65
 *  ‘a’ - 97
 *  空格 - 32
 *  换行符 - 10

ASCII表具体如下：  
![ASCII表][ASCII]

其中，ASCII表的范围是0-127，包含了字母、数字和一些符号，并不包含中文等其他符号，这就出现了Unicode字符集，这个字符集包含了各国语言的字符集，是世界通用的定长字符集，所有的字符都是16位。

Java中使用Unicode字符集如下：

输出：

c1 = a
    c1字符的对应编号为：97
    c2 = b
    c2字符的对应编号为：98
    Unicode奥运：奥运

可以看到，给char型变量赋值Unicode编码，输出了中文字符。

## （13）转义字符的概念和使用 ##

双引号本身有2层含义：

*  字符串的开头和结尾
 *  双引号符号自身

默认情况下双引号就是作为字符串的开头和结尾，要想使用双引号符号自身，则需要转义字符`\` 对双引号进行转义，这就组成转义字符`\"` ，主要转义字符如下：

简单使用如下：

/* 字符类型的使用 */
    
    public class CharTest { 
      
      public static void main(String[] args) { 
        
        // 1.声明char类型变量并初始化
        char c1 = 'a';
        // 2.打印变量值
        System.out.println("c1 = " + c1);
        System.out.println("c1字符的对应编号为：" + (int)c1);
        // 3.声明char类型变量并初始化
        char c2 = 98;
        // 4.打印变量值
        System.out.println("c2 = " + c2);
        System.out.println("c2字符的对应编号为：" + (int)c2);
        // 5.使用Unicode字符集展示中文
        char c3 = '\u5965';
        char c4 = '\u8fd0';
        System.out.println("Unicode奥运：" + c3 + c4);
        // 6.特殊字符的使用
        System.out.println();
        System.out.println("有人曾说\"一切反动派都是纸老虎\"");    // \"代表"
        System.out.println("有人曾说\'一切反动派都是纸老虎\'");    // \'代表'
        System.out.println("有人曾说\\一切反动派都是纸老虎\\");    /* \\代表\ */
      }
    }

输出：

c1 = a
    c1字符的对应编号为：97
    c2 = b
    c2字符的对应编号为：98
    Unicode奥运：奥运
    
    有人曾说"一切反动派都是纸老虎"
    有人曾说'一切反动派都是纸老虎'
    有人曾说\一切反动派都是纸老虎\

## （14）类型转换的概念和使用 ##

类型转换：

*  自动类型转换

一般指从小类型到大类型的转换。

*  强制类型转换

一般指从大类型到小类型的转换，格式为`target_var = (type)source_var;` 。

自动类型转换使用如下：

/* 基本数据类型之间的转换 */
    
    public class TransformTest { 
      
      public static void main(String[] args) { 
        
        // 1.声明2个变量并初始化
        byte b1 = 10;
        short s1 = 20;
        // 2.打印变量
        System.out.println("b1 = " + b1);
        System.out.println("s1 = " + s1);
        // 3.自动类型转换
        // 将变量b1的值赋值给s1
        s1 = b1;
        System.out.println("b1 = " + b1);
        System.out.println("s1 = " + s1);
      }
    }

输出：

b1 = 10
    s1 = 20
    b1 = 10
    s1 = 10

其中，第17行将变量b1的值赋值给s1，并覆盖s1中原来的数值，相当于从byte类型到short类型的转换，小到大、属于自动类型转换。

强制类型转换使用如下：

输出：

b1 = 10
    s1 = 20
    b1 = 10
    s1 = 10
    b1 = 10
    s1 = 10

其中，第21行将变量s1的数值赋值给变量b1，并覆盖b1原来的值，相当于从short类型到byte类型的转换，大到小、属于强制类型转换。

再来测试：

输出：

b1 = 10  
    s1 = 20  
    b1 = 10  
    s1 = 10  
    b1 = -128
    s1 = 128

可以看到，此时出现了损失，因为short类型转化为byte类型时，只取低8位，即`0b1000 0000` 对应的十进制为-128。

# 总结 #

变量和数据类型是Java的基础，是后面一切知识体系的根基，万丈高楼平地起，因此需要熟练掌握。

> 同时，本文只是知识文档的部分内容，如果要获取更完整的文档，可以私信交流。

[wolai -]: https://www.wolai.com/
[https_www.wolai.com_signup_invitation_SWEW7UI]: https://www.wolai.com/signup?invitation=SWEW7UI
[java]: /images/20220829/73a0a0158e80425e8e6671ad25b7268f.png
[5b20992e43a84861a118286f42bde895.png_pic_center]: /images/20220829/59fcf3612de64f1fb6e4bde029c5c186.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/dadf18d5b44d4d67aa93ef6668e15586.png
[ASCII]: /images/20220829/ed041f7300d74198a30efa32199eb6b6.png