【浅尝Java】变量与数据类型（含隐式类型转换、强制类型转换、整型与字符串互相转换等）

最新推荐文章于 2025-08-04 22:00:33 发布

原创最新推荐文章于 2025-08-04 22:00:33 发布 · 860 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #android

浅尝Java 专栏收录该内容

2 篇文章

订阅专栏

在这里插入图片描述

🍞自我激励：每天努力一点点，技术变化看得见

字面常量

我们认识每一门语言时，第一个程序就是“Hello World”，如下面程序所示：

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World");
	}
}

而上述程序中的System.out.println("Hello World");语句，不均程序何时运行，输出的都是"Hello World"，而"Hello World"就是字面常量。

常量的定义是：程序运行期间，固定不变的量。下方程序中，“Jammingpro”、18、3.141592、‘A’、true、false均为常量，并将其称为字面常量。

public class Date {
	public static void main(String[] args) {
		System.out.println("Jammingpro");
		System.out.println(18);
		System.out.println(3.141592);
		System.out.println('A');
		System.out.println(true);
		System.out.println(false);
	}
}

字面常量的分类：

字符串常量：由"“括起来的，比如"123”、“hello”、“小明”；
整型常量：程序中直接写出的数字（注意没有小数点），比如：100、1000；
浮点型常量：程序中直接写的小数，比如：3.141592、0.66；
字符型常量，由’‘单引号括起来的单个字符，比如’A’、‘1’、‘明’；
布尔型常量：只有true和false两种；
空常量：null

数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

基本数据类型有四类八种，四类分别是：整型、浮点型、字符型和布尔型。而八种如下表所示：

数据类型	关键字	内存占用	范围
字节型	byte	1字节	-128~127
短整型	short	2字节	-32768~32767
整型	int	4字节	$2^{31}~2^{31}-1$
长整型	long	8字节	$2^{63}~2^{63}-1$
单精度浮点型	float	4字节	有范围，一般不关注
双精度浮点型	double	8字节	有范围，一般不关注
字符型	char	2字节	0~65535
布尔型	boolean	没有明确规定	true和false

注意：
● 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
● 整型和浮点型都是带有符号的
● 整型默认为int型，浮点型默认为double型
● 字符串属于引用类型，该类型将于下文介绍

ps：这里也体现了Java代码具备可移植性，因为C语言的long类型在有的系统是4字节存储，有的是8字节存储，导致了long类型的范围不同。

相关拓展：什么是字节
字节是计算机中表示内存空间大小的基本单位。计算机使用二进制表示数据，规定8个二进制位为1个字节。而内存空间各个单位的关系如下所示：
1字节（byte）=8比特（bit）
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
若小明的电脑内存为8GB，则该内存包含8×1024×1024×1024字节。

变量

变量概念

在程序中，除了上述的始终不变的常量外，还包含了一些经常改变的内容，比如：时间、数学计算结果、分数等。在Java程序中，将这些经常改变的内容成为变量，而数据类型用来定义不同种类的变量。

语法格式

定义变量的语法格式为：

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

下面程序，展示如何定义变量，打印变量和修改变量：

public class Main {
    public static void main(String[] args) {
        // 定义整型变量count
        int count = 1;
        
        // 打印变量count
        System.out.println(count);
        
        // 修改变量数值并打印
        count = 100;
        System.out.println(count);
    }
}

在这里插入图片描述

整型变量

首先介绍整型变量，为什么整型变量分为byte、short、int和long呢？

举一个生活中的例子：小明和小东一个人买了10本书，一个人买了1本书，售货员给了小明大袋子，给了小东小袋子。若给小东一个大袋子，虽然能装下1本书，但有空间上的浪费。

计算机中的存储空间极其宝贵，若1字节能存储下来，我们就没必要给这个变量分配4字节。这就是为什么整型分为4个种类了。

在这里插入图片描述

字节型变量（byte）

首先介绍byte类型，它可以占据1字节的空间，它可以存储[-128, 127]区间的数据。下面程序展示了，如何定义byte类型，并打印byte类型所能存储的最大值和最小值。

public class Main {
    public static void main(String[] args) {
        // 定义byte类型的变量
        byte b = 2;
        System.out.println(b);

        // 打印byte类型的最大值和最小值
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
    }
}

ps：这里的Byte成为包装类，将于后续文章介绍，这里只要了解它.MAX_VALUE和.MIN_VALUE的用法即可。

短整型变量（short）

short类型占据2个字节，它可以存储[-32768,32767]区间的数据，它的包装类为Short。下方代码演示了定义short类型变量，并打印其可以存储的最大值和最小值。

public class Main {
    public static void main(String[] args) {
        // 定义short类型的变量
        short sh = 2;
        System.out.println(sh);

        // 打印short类型的最大值和最小值
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);
    }
}

在这里插入图片描述

若你此前学过类似于C、C++语言，它们支持定义变量的时候，不给它们初始值。但Java要求，在定义变量时必须给出初始值，否则会报错：

public class Main {
    public static void main(String[] args) {
        // 定义变量，没有初始化
        short sh;
        System.out.println(sh);
    }
}

在这里插入图片描述

注意：上述介绍的byte和short的范围都比较小，使用的情况也比较少，使用时注意不要超出范围。不知道初始化为什么数值时，可以将变量初始化为0。

整型变量（int）

int类型是使用最广泛的类型，它占据4个字节，存储范围为[ $2^{31}$ , $2^{31}-1$ ]，包装类为Integer。下面代码演示了如何定义int类型变量，并打印了它的存储范围。

public class Main {
    public static void main(String[] args) {
        // 定义int类型的变量
        int a = 2;
        System.out.println(a);

        // 打印int类型的最大值和最小值
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
}

在这里插入图片描述

长整型（long）

long的存储范围大于int，它占据8个字节，可以存储[ $2^{63}$ , $2^{63}-1$ ]区间的数据，它的包装类为Long。下面代码演示了如何定义long类型，并打印其存储范围。

public class Main {
    public static void main(String[] args) {
        // 定义long类型的变量
        long a = 2L;
        System.out.println(a);

        // 打印long类型的最大值和最小值
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
}

注意：在初始化long类型的数值时，要在数值后面加上l（小写L）或者L。由于小写L和数值1、大写I很相似，推荐使用大写L。

上面代码如果去掉数值后面的L，将其改为long a = 2;并不会出错。但如果初始化的数值大于int表示的最大数值2147483647，即若将long a = 2147483648;则程序会出错，因而在long类型初始化时，要在数值后面加L。

public class Main {
    public static void main(String[] args) {
        // 定义long类型的变量
        long a = 2147483678;
        System.out.println(a);

        // 打印long类型的最大值和最小值
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
}

在这里插入图片描述

浮点型变量

双精度浮点型（double）

Java中存储小数时，使用最广泛的是double类型。double占据8个字节，它的包装类为Double。但Double的存储形式与整型不同，表示范围不用使用2的几次方来计算，关于它的范围可以可以了解IEEE 754标准。

public class Main {
    public static void main(String[] args) {
        // 定义double类型变量
        double num = 3.1415926;
        System.out.println(num);

        // double的存储范围
        System.out.println(Double.MIN_VALUE);
        System.out.println(Double.MAX_VALUE);
    }
}

注意：这里的Double.MIN_VALUE打印的是double能存储的最小正数，Double.MAX_VALUE打印的是double能存储的最大整数。

下面看一段程序，并猜测其执行结果：

public class Main {
    public static void main(String[] args) {
        int num1 = 5;
        int num2 = 2;
        System.out.println(num1 / num2);
    }
}

在这里插入图片描述
注意：整型和整型的计算结果还是整型，会舍去小数点后面的数值，因而上述程序的结果为2。

再看另一个程序，并猜测其结果：

public class Main {
    public static void main(String[] args) {
        double num1 = 1.1;
        double num2 = 2.2;
        System.out.println(num1 * num2);
    }
}

在这里插入图片描述
注意：浮点数的存储空间有限，因而它精度也有限，它的计算结果趋近于真实值，但存在一定误差。

单精度浮点型（float）

float的包装类为Float，占据的空间仅4字节，因而它的表示范围和精度小于double，其他特性与double相同。由于float的精度更低，因而使用率也比较低。

ps：java规定，float初始值后面需要加字母f或者F。

public class Main {
    public static void main(String[] args) {
        float num1 = 1.1f;
        float num2 = 2.2f;
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num1 * num2);
    }
}

在这里插入图片描述

字符型变量

Java使用char类型来存储字符，并使用单引号+单个字符的形式表示字符的字面常量，char的包装类为Character。

public class Main {
    public static void main(String[] args) {
        char c1 = 'A';
        char c2 = '好';
        System.out.println(c1);
        System.out.println(c2);
    }
}

在这里插入图片描述

注意：若你此前学习过C、C++等语言，它们并支持使用单个char字符存储中文。这是由于C/C++使用的ACSII编码表示字符，占据1个字节。而Java使用Unicode编码表示字符，因此一个字符占据两个字节。因而Java能够表示出了中英外的多种字符。

若你直接使用cmd命令行执行javac命令时出现如下错误，则需要在执行javac时加上-encoding UTF-8选项。
在这里插入图片描述

布尔型变量

生活中我们有很多需要真和假两种数值的情况，例如：A说“小明中了1个亿的票”，B说“真的假的？”，A说“假的”。
在这里插入图片描述
表示真和假的值成为布尔值，使用boolean表示，它只有true和false两种值，true表示真，false表示假。boolean的包装类为Boolean。

public class Main {
    public static void main(String[] args) {
        boolean flag1 = true;
        boolean flag2 = false;

        System.out.println(flag1);
        System.out.println(flag2);
    }
}

在这里插入图片描述
ps：java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令。在Oracle公司的虚拟机实现中，boolean占1个字节。

注意：Java的boolean类型不能和int互相转换，不存在1表示true，0表示false的用法。

类型转换

Java是一种强类型的编程语言，当不同类型的变量相互赋值的时候，会有严格的校验。当参与运算的数据类型不一致时，就需要类型转换。Java中的类型转换分为：自动类型转换（隐式类型转换）和强制类型类型转换（显示类型转换）。

自动类型转换

自动类型转换表现为：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

特点是：数据范围小的转换为数据范围大的，会自动进行转换。

下面代码演示了自动类型转换，int类型的表示范围小于long类型，因而可以直接赋值。

public class Main {
    public static void main(String[] args) {
        int num1 = 123456789;
        long num2 = num1;
        System.out.println(num1);
        System.out.println(num2);
    }
}

在这里插入图片描述
若将上面代码反过来，将long类型赋值给int，则会出错。


public class Main {
    public static void main(String[] args) {
        long num1 = 123456789;
        int num2 = num1;// 出错！！
        System.out.println(num1);
        System.out.println(num2);
    }
}

在这里插入图片描述
在浮点型中，双精度浮点型的范围大于单精度浮点型，因而double赋值给float会出错，而float赋值给double会进行隐式类型转换。


public class Main {
    public static void main(String[] args) {
        float num1 = 2.2f;
        double num2 = num1; // 隐式类型转换（OK）
        System.out.println(num1);
        System.out.println(num2);
        
        float num3 = num2; // 错误，ERROR!!
        System.out.println(num3);
    }
}

在这里插入图片描述

在编译器识别时，整数默认识别为int类型，只要整数不超过byte类型可以直接赋值为byte变量，但若超过byte类型则会报java: 不兼容的类型: 从int转换到byte可能会有损失，short同理。而小数编译器默认识别为double类型，需要在小数后面加上f或F，以告诉编译器其为float类型。

强制类型转换

当大范围类型转换为小范围类型，或者高精度类型转换为小精度类型，无法自动完成（无法自动类型转换），则需要使用强制类型转换。

特点：数据范围大的到数据范围小的。

当long转为int，将double转为float，将int转为byte等都需要强制类型转换。代码如下所示：

public class Main {
    public static void main(String[] args) {
        long num1 = 123456;
        int num2 = (int)num1;
        System.out.println(num2);

        float num3 = 1.23f;
        double num4 = (double)num3;
        System.out.println(num4);

        byte num5 = 123;
        int num6 = (int)num5;
        System.out.println(num6);
    }
}

在这里插入图片描述
但不相干类型无法相互转换，例如：boolean转换为int。

public class Main {
    public static void main(String[] args) {
        boolean flag = true;
        int num1 = (int)flag;
    }
}

在这里插入图片描述

注意：
● 不同数值类型的变量转换时，表示范围小的类型能隐式转换为范围大的类型；
● 若需要将表示范围大的转换为表示范围小的，需要强制类型转换，但可能存在精度丢失；
● 强制类型转换不一定能成功，不相干的类型不能相互转换。

注意：由于编译器会默认将整数识别为int类型，若小于byte范围可以直接赋值给byte变量，否则需要强制类型转换。编译器默认将小数识别为double，需要在小数后面加f或F才能识别为float，否则也需要强制类型转换。

public class Main {
    public static void main(String[] args) {
        byte num1 = (byte)123456;
        System.out.println(num1);

        float num2 = (float)3.1415926;
        System.out.println(num2);
    }
}

在这里插入图片描述

类型提升

不同类型的数据之间计算时，小范围数据类型会被自动提升为大的数据类型。

int和long之间：int会提升为long

public class Main {
    public static void main(String[] args) {
        int num1 = 123;
        long num2 = 123;
        
        long sum1 = num1 + num2;	// OK
        int sum2 = num1 + num2;		// ERROR

        System.out.println(sum1);
        System.out.println(sum2);
    }
}

在这里插入图片描述

范围小于int的类型：都会提升为int

代码示例1：

public class Main {
    public static void main(String[] args) {
        byte num1 = 1;
        byte num2 = 2;

        byte sum = num1 + num2;
        System.out.println(sum);
    }
}

在这里插入图片描述

代码示例2：

public class Main {
    public static void main(String[] args) {
        short num1 = 1;
        short num2 = 2;

        short sum = num1 + num2;
        System.out.println(sum);
    }
}

在这里插入图片描述

代码示例3：

public class Main {
    public static void main(String[] args) {
        short num1 = 1;
        byte num2 = 2;

        short sum = num1 + num2;
        System.out.println(sum);
    }
}

在这里插入图片描述

总结：
● 不同类型的数据混合运算，范围小的会被提升为范围大的；
● 对于short，byte这种比4个字节小的类型，会提升成4个字节的int，再计算；

字符串类型

在Java中存储字符串类型时，将变量定义为String即可，而String属于抽象数据类型，并不属于基本数据类型。

public class Main {
    public static void main(String[] args) {
        // 定义String类型的变量
        String s1 = "Jammingpro";
        String s2 = " hello world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 + s2);// 将s1和s2拼接在一起
    }
}

在这里插入图片描述

在一些场景下，我们需要实现字符串和整型数据之间的转换：

int转为String

下方代码演示了int转为String的两种方法：

public class Main {
    public static void main(String[] args) {
        // 定义int类型数据
        int num = 123456;
        // 转换为String类型方法1
        String s1 = String.valueOf(num);
        System.out.println(s1);
        // 转换为String类型方法2
        String s2 = num + "";
        System.out.println(s2);
    }
}

String转为int

public class Main {
    public static void main(String[] args) {
        // 定义String类型变量
        String s = "123456";
        // 转换为int类型
        int num = Integer.parseInt(s);
        System.out.println(num);
    }
}