Java数据类型与变量详解

一、字面常量

        字面常量（Literal Constant） 是在程序中 直接写出来、表示固定值的量。
        通俗来说，就是在程序中敲出来的数字，通常都是写死的，譬如123、3.14、A等等

        字面常量通常被分为以下几类：
        

二、常量与 final 关键字

        刚刚介绍了字面常量，但字面常量与常量是有本质区别的：通俗来说，常量是一个带有变量名的字面常量，可以被反复使用和引用，而字面常量只是一个单纯的值而已。 

•    字面常量
  • 就是在程序中被直接写出来的固定值，例如：123，3.14、' a '
  • 本身只是一个值，没有名字等
  • 示例：

    int x = 18;
    double PI = 3.14;

    这里的 18 与 3.14 就是字面常量

•   常量
  • 使用关键字或者宏定义（Java中没有宏定义）给一个固定值起了名字
  • 在程序中可以被多次引用
  • 示例：

    final int x = 18;
    final double PI = 3.14;

    这里的 int x = 18; 与 double PI = 3.14 就是常量

项目	字面常量	常量
含义	程序中直接写出来的固定值	使用标识符定义、值不可变的变量
是否含有名字	不含有名字，就是本身	有名字，可以被引用
能否被重复使用	不允许	可以
能否修改	不可被修改	原则上不可被修改
例子	3.14、'A'、123	PI = 3.14、Age = 18

        在Java中，可以通过关键字 final 将 变量 变为 常量，如下

从截图 ① 可以看见，如果使用了 final 修饰了变量，那么其值就不可被再次修改，而 ② 没有使用 final 对变量进行修饰，则 x 与 PI 便可以被修改。

三、数据类型

        在 Java 中通常将数据类型分为两大类 分别是：基本数据类型 与 引用数据类型

        基本数据类型

        1、整形

               在Java中，整形可分为四类，其分别是 字节型（byte）、短整型（short）、整形（int）、长整型（long）。

                需要注意的一点是，在Java中，无论是16位还是32位操作系统，int 都是占用 4 字节，long 都是占用 8 字节。

类型	关键字	内存占用	表示范围
字节型（byte）	byte	1byte / 8bit	-2⁷ ~ 2⁷-1	-127~128
短整型（short）	short	2byte / 16bit	-2¹⁵ ~ 2¹⁵-1	-32768~32767
整型（int）	int	4byte / 32bit	-2³¹ ~ 2³¹-1	-2147483648~  2147483647
长整型（long）	long	8byte / 64bit	-2⁶³ ~ 2⁶³-1	-9223372036854776000~ 9223372036854775999

        2、浮点型

                在Java中，浮点型可分为两类，其分别是  单精度浮点型（float）、双精度浮点型（double）。

                需要注意的是，由于存储方式的差异、浮点型存入的小数并不精确

类型	关键字	内存占用	表示范围
单精度浮点型	float	4byte / 32bit	-3.4028235 × 10^38  ~   3.4028235 × 10^38
短整型（short）	short	2byte / 16bit	-1.7976931348623157 × 10^308  ~ 1.7976931348623157 × 10^308

        3、字符型   

类型	关键字	内存占用	表示范围
字符型	char	2byte / 16bit	0 ~ 65535

        4、布尔类型

类型	关键字	内存占用	表示范围
布尔类型	boolean	没有明确说明	true / false

四、变量

        在上述的介绍中，我们可以了解到常量是用于记录不可变化的量，譬如性别、一周的天数等等，这些都是常量，那么对于年龄、身高、体重这类可以变化的值，在Java程序设计中就被称为变量。

        定义格式：

数据类型 变量名 = 初始值

譬如：

int age = 18; // 定义了一个 年龄 变量  其值为18
double weight = 50;  // 定义了一个 体重 变量  其值为50

上述代码也可以被称作初始化。

如果只定义了变量名，但没有赋予初始值，那么就算没有完成初始化。在变量被使用之前，必须先完成数据的初始化；如果没有完成，就会出现编译器报错的情况，例如：

public static void main(String[] args) {
        int age;
        System.out.println(age);
    }

// java: 可能尚未初始化变量age

因此，需要注意的一点是，在变量被使用之前，一定要确保变量已经被正常初始化，否则会导致编译错误。

但是，有些特殊情况，看似代码中我们并没有显式地进行初始化，却依然可以正常编译和使用。这并不是因为这些情况可以不用初始化，而是编译器会自动将其赋值为默认值（例如整数类型为 0），也就是发生了隐式初始化。而前面提到的代码属于显式初始化的情况。

五、字符串

        字符串的拼接
        先看下面的代码：

public static void main(String[] args) {
        char a = 'a';
        char b = 'b';
        char c = 'c';
        System.out.println(a+b+c);       // 294
        System.out.println(a+b+""+c);    // 195c
        System.out.println("" + a+b+c);  // abc

    }

• a + b + c → 294

  • 原因：a、b、c 都是 char 类型，在参与 + 运算时会先被自动转换为 int（即 Unicode 编码），然后做数值相加。

  • 'a' → 97， 'b' → 98， 'c' → 99

  • 97 + 98 + 99 = 294

• a + b + "" + c → 195c

  • 原因：a + b 先执行，得到 195（97+98），然后遇到字符串 "" 时，后续的 + 运算变为字符串拼接

  • "195" + c → "195" + 'c' → "195c"

• "" + a + b + c → abc

  • 原因：字符串 "" 放在最前面，使得整个表达式的 + 运算都变为字符串拼接

  • 等价于 ("" + a) + b + c → "a" + "b" + "c" → "abc"

        基本数据类型 转字符串

通常有三个办法可以将基本数据类型转换为字符串

• String.valueOf()
• 对应包装类型.toString()
• 使用 + "" 进行拼接

如下：

public static void main(String[] args) {
        int age = 18;
        double weight = 65.2;
        double high = 181.7;
        System.out.println(String.valueOf(age) + 1);// “18” + 1  ---> 181
        System.out.println(Integer.toString(age) + 1);// “18” + 1  ---> 181

        System.out.println(String.valueOf(high) + 1);// “181.7” + 1  ---> 181.71
        System.out.println(Double.toString(high) + 1);// “181.7” + 1  ---> 181.71
        
        System.out.println(String.valueOf(weight) + 1);//  " 65.2 " + 1  ---> 65.21
        System.out.println(Double.toString(weight) + 1);//  " 65.2 " + 1  ---> 65.21

    }

六、类型转换

        隐式类型转换

public static void main(String[] args) {
        //  隐式类型转换
        int a = 10;
        double d = 3.14;
        System.out.println(a+d);//发生隐式类型转换  -->13.14
    }

通过上面的代码可以看到，int 类型的 a 与 double 类型的 d 可以直接进行算术运算，输出结果为 13.14。

这是因为在运算前发生了 隐式类型转换（Implicit Type Conversion）：编译器会自动将 int 类型的 a 提升为 double，然后再进行运算。

可以理解为：

System.out.println(a + d); // 实际上等价于 System.out.println((double)a + d);

总结：隐式类型转换发生在“安全”的情况下，不会丢失信息，例如 int → double。

        显式类型转换

顾名思义，显式类型转换（Explicit Type Conversion / 强制类型转换） 是程序员主动指定的类型转换

 public static void main(String[] args) {
        short a = 97;
        System.out.println((char) a);
    }
// 结果 a

在这个例子中，我们将 short 类型的 a 强制转换为 char 类型，然后输出结果 'a'。

总结：显式类型转换需要程序员明确指定 (类型)，有可能丢失信息或精度，所以要谨慎使用。

七、类型提升

        不同类型的数据进行运算时，范围较小的数据类型会自动提升为范围较大的数据类型，这种行为被称为 类型提升。

        例如，当 int 与 long 等多种类型同时参与运算时，范围较小的 int 会被提升为范围最大的 long，再进行计算。就拿刚才的例子来说，int 会被转换为 long 后再参与运算。

        需要注意的是，short 与 byte 类型在运算时也会先被提升为 int。这是因为计算机 CPU 通常以 4 字节（32 位） 为单位从内存中读取数据，为了硬件实现的方便，低于 4 字节的类型（如 byte、short）会先提升为 int 再参与计算。
因此，以下场景会发生编译错误：

public static void main(String[] args) {
        byte a1 = 1;
        byte a2 = 2;
        byte a = a1 + a2;  // error: java: 不兼容的类型: 从int转换到byte可能会有损失
        short d1 = 11;
        short d2=  2;
        short d = d1 +d2;  // error: java: 不兼容的类型: 从int转换到short可能会有损失
    }

---

end*