<Java>2 变量

本文最后更新于：2023年6月27日 上午

2 变量

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

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

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

如何声明变量：

int a;
a = 100;

int b = 100;

int c = 5, d;

2.1 变量使用注意事项

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

2.2 程序中 + 的使用

  1. 当左右两边都是数值型，做加法运算

  2. 当左右两边任意一方为字符串，做拼接运算

  3. 运算顺序是从左到右的

    System.out.println(1 + 1 + "a" + 1 + 1);		// 输出 2a11

2.3 Java 数据类型

#基本数据类型（本章）

  • 数值型

    • 整数类型：

      • byte：占用 1 字节
      • short：占用 2 字节
      • int：占用 4 字节
      • long：占用 8 字节

    • 浮点（小数）类型：

      • float：占用 4 字节
      • double：占用 8 字节

  • 字符型

    • char：存放单个字符，占用 2 字节

  • 布尔型

    • boolean：存放 true（真），false（假）。占用 1 字节

#引用数据类型（复合数据类型）

2.4 整数类型

用于存放整数值

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

使用细节：

  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;

如果基本的整数、浮点类型不能满足范围、精度的需求，可以使用 “大数”

—— 大数，见 [12.8 BigInteger 和 BigDecimal 类]

2.5 浮点类型

可以表示一个小数

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

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

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

2.5.1 使用细节

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

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

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

    十进制数形式：5.13、315.4F、.414

    科学计数法：5.12e2 即[5.12 × 102]、5.12E-2 即[5.12 / 102]

  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. 由于不同处理器寄存浮点数的策略可能不同，浮点数运算的结果也可能不同。

    —— 见 [12.1.4 strictfp 关键字]

2.6 字符类型

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

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

2.6.1 使用细节

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

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

    要输出那个整数，用 int

    char c1 = 'a';
System.out.println((int)c1);

  3. char 是可以进行运算的，其相当于一个整数。注意与 [2.2 示例] 的区别

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

  4. 字符允许使用转义符（见 [1.8 Java 转义字符]）

    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.6.2 字符本质与编码表

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

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

    ASCII 编码表，占用 1 byte，共有 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 编码表，可以存放繁体中文（香港，台湾）

  • UTF-16 编码采用不同长度的编码表示所有 Unicode 码点。包含从 U+0000 到 U+FFFF 的经典 Unicode 代码（16位，1 个代码单元），以及 U+10000 到 U+10FFFF 的辅助字符（32位，2 个代码单元）

  • 在 Java 中，char 类型描述的是 UTF-16 编码中的 1 个代码单元。

    字符串中的一个辅助字符（如 🎶）可能占用 2 个代码单元。这个场合，使用 char 可能会导致错误

    String str = "🎶Melody🎶";
char c = str.charAt(1);			// <———— 这个场合，c 是 🎶 符号的第二个代码单元而非 'M'

    因此，一般不建议在程序中使用 char 类型

2.7 布尔类型

boolean 只允许取值 ture 或 false ，没有 null。适用于逻辑运算，通常用于程序流程控制

if while do-while for

使用细节：

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

  2. 不能让布尔类型转换为其他类型。如需转换，请使用如下方法：

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

    ——见 [3.5 三元运算符]

2.8 基本数据类型转换

2.8.1 自动类型转换

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

char > int > long > float > double

byte > short > int > long > float > double

例子：int a = 'c' 或者 double b = 80

#2.8.1.1 使用细节

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

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

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

    byte a = 1;

    byte b = 1;

    a + b 结果是 int 类型

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

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

2.8.2 强制类型转换

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

#2.8.2.1 使用细节

  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.8.3 基本数据类型和 String 的转换

  • 基本类型转 String：基本数据类型加上 " "。即利用了 [2.2.2] 中的方法。

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

  • String 转基本数据类型：通过基本数据类型的包装类调用 parseXX 方法。

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

    特别的，把 String 转换为 char

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

#2.8.3.1 使用细节

  1. 将 String 转成基本数据类型时，要保证其能转换为有效数据。即不能把 "Hello" 转换成 int。
  2. 如果格式不正确，会抛出异常，程序会中止。
Java
#笔记 #Java
<Java>2 变量
https://i-melody.github.io/2021/11/22/Java/入门阶段/2 变量/
作者
Melody
发布于
2021年11月22日
许可协议