【JavaSE】字面常量 && 数据类型 && 变量 && 类型转换 && 类型提升

原创

lirendada

发布于 2026-02-28 09:15:08

640

文章被收录于专栏：JavaJava

Ⅰ. 字面常量

程序运行期间固定不变的量称为常量，比如：一个礼拜七天，一年12个月等。

字面常量的分类：

字符常量：由单引号括起来的当个字符，比如：'A'、'1'。
字符串常量：由双引号括起来的，比如 "12345"、"hello"、"你好"。
整形常量：程序中直接写的数字（注意没有小数点），比如：100、1000。
浮点数常量：程序中直接写的小数，比如：3.14、0.49。
布尔常量：只有两种 true 和 false
空常量：null

注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

public class dataTest {
    public static void main(String[] args) {
        System.out.println(10);
        System.out.println(10.250);
        System.out.println('C');
        System.out.println("lirendada");
        
        // 也可以直接使用printf像C语言那样子输出
        System.out.printf("%s\n", "liren");
        
        // 也可以不换行的输出
        System.out.print("lirenIg");
        System.out.print("lirenIg");
        System.out.println("");
        
        System.out.println(true);
        System.out.println(false);
    }
}

Ⅱ. 数据类型

注意事项：

不论是在16位系统还是32位系统，java的数据类型占用字节都是固定的，体现出了强大的可移植性。
【整形】和【浮点型】都是有符号类型，在java中，都是有符号类型！
【整型】默认为int型，【浮点型】默认为double，若想表示long，一般在整型数值后加L；若想表示float，一般在浮点型后面加f
字符串属于引用类型
当赋值的字面值（若是变量的话则是进行隐式类型转化）大于这个变量能够保存的最大值的时候，会报错，如下所示：

public static void main(String[] args) {
     System.out.println(Integer.MAX_VALUE);
     System.out.println(Integer.MAX_VALUE + 1);
     System.out.println(2147483647 + 1);
     System.out.println(2147483648); // ❌这个会报错，因为单独一个数值不参加运算的话是一个字面值
 }

为什么 java 中的 char 类型是2个字节呢❓❓❓

因为C语言中使用的是 ASCII 码字符集，能表示的字符比较少，所以其中的 char 类型是1个字节。但是 java 中使用的字符集是 Unicode，能表示更多的字符如希腊文等等，所以所需的空间更大，所以 java 中的 char 类型是2个字节的！值得注意的是 Unicode 是包含 ASCII 字符集的！

Ⅲ. 变量

注意：java 中不存在全局变量，因为在 java 中内容都是写在方法里面的，不存在方法之外的内容！所以 java 中只有局部变量、静态、非静态成员变量。

一、语法格式

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

如果变量没有初始化就使用的话，那么就会直接报错！如下所示：

int d, e;
System.out.println(d); // d报错，但e不会报错

二、整型变量

① 整型变量 `int`

public static void main(String[] args) {
    // 方式一：在定义时给出初始值
    int a = 10;
    System.Out.println(a);
    
    // 方式二：在定义时没有给初始值，但使用前必须设置初值
    int b;
    b = 10;
    System.Out.println(b);
    
    // 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
    int c;
    System.Out.println(c);
    c = 100;
    
    // int型变量所能表示的范围：
    System.Out.println(Integer.MIN_VALUE);
    System.Out.println(Integer.MAX_VALUE);
    
    // 注意：在定义int性变量时，所赋值不能超过int的范围
    int d = 12345678901234; // 编译时报错，初值超过了int的范围
}

注意事项：

int不论在何种系统下都是4个字节
在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
变量在使用之前必须要赋初值，否则编译报错
int 的包装类型为 Integer

② 长整型变量 `long`

public static void main(String[] args) {
    long a = 10; // 这里其实10是int，通过隐式类型提升变成了long
    System.out.println(a);
    
    long b = 10L; // 这里的10L才是long类型，是显式强调的
    System.out.println(b);
    
    System.out.println(Long.MAX_VALUE);
    System.out.println(Long.MIN_VALUE);
}

注意事项：

长整型变量的初始值后加L或者l，推荐加L
长整型不论在那个系统下都占8个字节
long的包装类型为Long

③ 短整型变量 `short`

public static void main(String[] args) {
     short a = 10;
     System.out.println(a);
    
     System.out.println(Short.MAX_VALUE);
     System.out.println(Short.MIN_VALUE);
}

注意事项：

short在任何系统下都占2个字节
short的表示范围为：-32768 ~ 32767
short的包装类型为Short

④ 字节型变量 `byte`

public static void main(String[] args) {
    byte a = 10;
    System.out.println(a);
    
    System.out.println(Byte.MAX_VALUE);
    System.out.println(Byte.MIN_VALUE);
}

注意事项：

byte在任何系统下都占1个字节
byte的范围是：-128 ~ 127
字节的包装类型为Byte

三、浮点型变量 `float` `double`

public static void main(String[] args) {
    double d = 3.14;
    System.out.println(d);
    
    // 结果依然是 int
    int a = 1;
    int b = 2;
    System.out.println(a / b);
    
    // 结果为 double
    double da = 1;
    double db = 2;
    System.out.println(da / db);
    
    float f = 3.145f; // float类型赋值时候最好要加 f或 F
    System.out.println(f);
}

注意事项：

在 Java 中 , int 除以 int 的值仍然是 int（会直接舍弃小数部分）
double在任何系统下都占8个字节
double的包装类型为Double
float 类型在 Java 中占4个字节。
1. 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float。
float的包装类型为Float。

四、字符型变量 `char`

public static void main(String[] args) {
    char c1 = 'A'; // 大写字母
    char c2 = '1'; // 数字字符
    System.out.println(c1);
    System.out.println(c2);
    
    // 注意：java中的字符可以存放整形
    char c3 = '帅';
    System.out.println(c3);
}

注意事项:

计算机中的字符本质上是一个整数。在 C 语言中使用 ASCII 表示字符，而 Java 中使用 Unicode 表示字符。因此一个字符占用两个字节，表示的字符种类更多，包括中文。
char的包装类型为Character。

五、布尔类型 `boolean`

public static void main(String[] args) {
    boolean b = true;
    System.out.println(b);
    b = false;
    System.out.println(b);
    
    // 报错，因为 int 和 boolean 类型是不相通的
    //System.out.println(b + 1);
}

注意事项：

boolean 类型的变量只有两种取值，true 表示真，false 表示假。
boolean 类型和 int 不能相互转换，不存在 1 表示 true，0 表示 false 这样的用法。
Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，boolean占1个字节。
boolean的包装类型为Boolean。

六、字符串类型 `String`

public static void main(String[] args) {
    String s1 = "liren ";
    String s2 = "love yt";
    
    System.out.println(s1 + s2); // 拼接两个String类型变量
}

在有些情况下，需要将字符串和整形数字之间进行转换：

int 转化为 String：

public static void main(String[] args) {
    int a = 250;
    String tmp = String.valueOf(a); // 使用String里面的valueOf接口转换
    
    System.out.println(tmp + 1); // 转化为字符串后+1其实就是拼接
}

2. String 转化为 int：

public static void main(String[] args) {
    String s = "1234";
    int b = Integer.valueOf(s); // 使用Interger里面的valueOf接口转换
    
    System.out.println(b + 1); // 转化为int后+1其实就是数值+1
}

Ⅳ. 类型转换

Java 作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有教严格的校验，如下所示：

一、隐式类型转换

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。若是数据范围大的 ---> 数据范围小的，那么只能通过下面讲的强制类型转换才能通过！

public static void main(String[] args) {
    int a = 10;
    long b = 10L;
    
    b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
    a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
    
    byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
    byte b2 = 128; // 编译失败，257超过了byte的数据范围，有数据丢失
}

二、显式类型转换

当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大到数据范围小的，需要强制转换。

public static void main(String[] args) {
    int a = 10;
    long b = 10L;
    b = a;
    a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则报错
    
    byte b1 = 12;        // 12默认为int，没有超过byte范围，隐式转换
    byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
    
    boolean flag = false;
    a = (int)flag;     // 编译失败：类型不兼容
    flag = (boolean)a; // 编译失败：类型不兼容
}

注意事项：

如果需要把范围大的类型赋值给范围小的，需要强制类型转换，但是可能精度丢失。
将一个字面值常量进行赋值的时候，Java 会自动针对数字范围进行检查。
强制类型转换不一定能成功，不相干的类型不能互相转换，比如 boolean 和 int 的转换是不成立的。

Ⅴ. 类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

int 与 long 之间： int 会被提升为 long

int a = 10; 
long b = 20; 
int c = a + b;  // 编译失败: a + b==》int + long--> long + long 赋值给int时会丢失数据 
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

2. byte 与 byte 的运算：

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 

// 编译报错 
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失 
 byte c = a + b;
        ^

结论 : byte 和 byte 都是相同类型，但是出现编译报错。原因是虽然 a 和 b 都是 byte，但是计算 a + b 会先将 a 和 b 都提升成 int，再进行计算，得到的结果也是 int,，这是赋给 c，就会出现上述错误。由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据，为了硬件上实现方便，诸如 byte 和 short 这种低于 4 个字节的类型，会先提升成 int，再参与计算。

正确的写法如下所示：

byte a = 10;
byte b = 20;
byte c = (byte)(a + b); // 先转换类型，再赋值
System.out.println(c);

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

变量

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

变量

登录后参与评论

0 条评论

热度