本文详细介绍了Java中的基本数据类型，包括整数型（byte, short, int, long）、浮点型（float, double）、布尔型（boolean）和字符型（char）。讲解了不同数据类型占用的字节数、取值范围以及字符编码，特别是字符型在Unicode编码中的应用。此外，还讨论了数据类型间的转换规则，包括自动类型转换和强制类型转换，并举例说明了混合运算中的类型处理。最后，探讨了Java中基本数据类型的用途和限制，如byte类型的取值范围和整数型字面量的处理。
目录
知识框架
🏀数据类型
🥏数据类型的作用和分类
❤️数据类型用来声明变量，程序在运行过程中根据不同的数据类型分配不同大小的空间。
⭐️例如：int i = 10；double d = 1.23； i变量和d变量类型不同，空间大小不同！❤️第一种：基本数据类型
⭐️基本数据类型又可以划分为4大类8小种：
第一类：整数型
byte，short，int，long
第二类：浮点型
float，double
第三类：布尔型
boolean：只有两个值true和false，true表示真，false表示假
第四类：字符型
char：java中规定字符型字面量必须使用单引号括起来；属于文字⭐️8小种：byte，short，int，long，float，double，boolean，char
❤️第二种：引用数据类型
⭐️字符串型String属于引用数据类型；String字符串不属于基本数据类型范畴
⭐️java中除了基本数据类型之外，剩下的都是引用数据类型。
🥏不同数据类型占用的字节
类型 占用字节数量(byte)
------------------------------------
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2❤️整数型：byte short int long有什么区别？浮点型：float和double有什么区别？
区别：占用的空间大小不同❤️关于计算机存储单位？
⭐️计算机只能识别二进制。（1001101100...）
1字节 = 8bit（8比特）《---》 1byte = 8bit
1bit就是一个1或0.
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB⭐️例如：
byte b = 2; 在计算机中是这样表示的：00000010
short s = 2; 在计算机中是这样表示的：00000000 00000010
int i = 2；在计算机中是这样表示的：00000000 00000000 00000000 00000010
🥏取值范围
❤️例如：byte类型的取值范围是 [-128 ~ 127] 共可以标识256个不同的数字
⭐️byte类型的最大值是怎么计算出来的？
byte是1个字节，是8个比特位，所以byte可以存储的最大值是：01111111
⭐️注意：在计算机当中，一个二进制位最左边的是符号位，当为0时表示正数，当为1时表示负数。所以byte类型最大值是：01111111；就是。
⭐️有几个取值范围需要记住：
(1个字节)byte: [-128 ~ 127]
(2个字节)short:[-32768 ~ 32767] 可以表示65536个不同的数字
(4个字节)int: [-2147483648 ~ 2147483647]
(2个字节)char: [0~65535] 可以表示65536个不同的数字
⭐️short和char实际上容量相同，为什么表示的范围不同呢？
因为char表示的是文字，文字没有正负之分，可以看做是无符号数(>=0)的，取值范围就是：【
】；而short表示的是数，有正负之分，是有符号数，取值范围是：
【
】
🥏字符编码
❤️对于8种基本数据类型来说：
⭐️其中byte，short，int，long，float，double，boolean这7种类型计算机表示起来比较容易，因为他们都是数字；其中布尔类型只有两个值true和false。⭐️对于char类型来说计算机表示起来比较麻烦，因为char对应的是文字，每一个国家的文字不一样，文字不能直接通过“自然算法”转换成二进制。这就需要字符编码！
⭐️什么是字符编码？
字符编码是人为的定义的一套转换表。
在字符编码中规定了一系列的文字对应的二进制。
字符编码其实本质上就是一本字典，该字段中描述了文字与二进制之间的对照关系。
⭐️字符编码涉及到编码和解码两个过程，编码和解码的时候必须采用同一套字符编码方式， 如果编码和解码采用的不是同一个编码方式，会出现乱码！⭐️最先支持的文字是英文，对应的字符编码方式是：ASCII码。ASCII码采用1byte进行存储，因为英文字母是26个。（键盘上所有的键全部算上也超不过256个。1byte可以表示256种不同的情况。所以英文本身在计算机方面就占优势。）
⭐️例如： 'a' --(采用ASCII码进行编码)-> 01100001
01100001 --(采用ASCII码进行解码)-> 'a'
'a' ---> 97 'A' ---> 65 '0' ---> 48
⭐️随着计算机语言的发展，后来国际标准组织制定了ISO-8859-1编码方式，又称为latin-1编码方式，向上兼容ASCII码。但不支持中文。⭐️在java中，java语言为了支持全球所有的文字，采用了一种字符编码方式叫做unicode编码。unicode编码统一了全球所有的文字，支持所有文字。具体的实现包括：UTF-8 UTF-16 UTF-32....
⭐️需要记住：
ASCII（'a'是97 'A'是65 '0'是48...）
ISO-8859-1（latin-1）
GB2312
GBK
GB18030
Big5（大五码，繁体中文）
unicode（utf8 utf16 utf32）
其中：GB2312<GBK<GB18030 （容量的关系）
🥏八种数据类型详解
整数型：byte、short、int、long
浮点型：float、double
布尔型：boolean
字符型：char
🥅字符类型：char
❤️char类型
⭐️例1：
1、char占用2个字节
2、char的取值范围：[0-65535]
3、char采用unicode编码方式
4、char类型的字面量使用单引号括起来
5、char可以存储一个汉字
public class CharTest01{
public static void main(String[] args){
//1.char存储1个汉字，一个汉字占用2个字节，java中的char类型占用2个字节，刚好
char c1 = '中';
System.out.println(c1);
//2.存储一个英文字母
char c2 = 'a';
System.out.println(c2);
//3.0如果加上单引号的话，0就不是数字0了，就是文字0，它是1个字符。
char c3 = '0';
System.out.println(c3);
//4.错误: 不兼容的类型: String无法转换为char
char c4 = "a";//err
//5.错误: 未结束的字符文字
char c5 = 'ab';//err
//6.错误: 未结束的字符文字
char c6 = '1.08';//err
}
}⭐️例2：转义字符"\"
关于java中的转义字符java语言中“\”负责转义。例如：\t 表示制表符tab、 \n是换行等
public class CharTest02{
public static void main(String[] args){
//1.\t实际上是1个字符，不属于字符串
//两个字符合在一起表示一个字符，其中\t表示“制表符tab”
char c2 = '\t'; //相当于键盘上的tab键
System.out.println("abc\tdef");//打印abc def
//2.println和print的区别
System.out.println(); // 换行
System.out.print(); // 不换行
//3.\n表示换行；所以print+\n的效果实际上就等价于println
System.out.println(); <===> System.out.print()+ System.out.print("\n")
//4.利用转义字符"\"；输出具有特殊意义的字符
//4.1假设现在想在控制台输出一个 ' 字符怎么办？
System.out.println('\'');
//4.2假设现在想在控制台输出一个 \ 字符怎么办？
System.out.println('\\');
//4.3双引号括起来的是字符串；希望输出的结果是："test"
System.out.println("\"test\"");
System.out.println("“test”"); //内部的双引号我用中文的可以
//5.\u表示后面的是一个字符的unicode编码；unicode编码是十六进制的
char x = '\u4e2d';
System.out.println(x); // '中',因为'中'的unicode码对应的就是4e2d
}
}
补充：如何实现把一个汉字找到对应的unicode码？
利用bin目录下的native2ascii.exe命令，输入后回车；输入中文汉字回车，就会自动转换为对应的unicode码！
注：这个命令在JDK9以后就没有了！
⭐️例3：
1、当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。例如：char i = 97；打印出来的是字符‘a’
2、当一个整数int没有超出byte short char的取值范围的时候，这个整数可以直接赋值给byte short char类型的变量
public class CharTest03{
public static void main(String[] args){
//1.这里会做类型转换；97是int类型（默认当做int处理）；c2是char类型
char c2 = 97;
System.out.println(c2); // 'a'；根据ASCII码输出对应的值
//2.char类型取值范围：[0~65535]
char c3 = 65535; // 实际上最终是一个“看不懂”的字符；但不会报错！
System.out.println(c3);
//3.错误: 不兼容的类型: 从int转换到char可能会有损失
char c4 = 65536;//err，超过char的取值范围会报错！
//怎么解决以上问题？进行强制类型转换！
char c4 = (char)65536;//超过范围就进行强制类型转换
}
}🥅整数型类型：byte、short、int、long
❤️int类型和long类型
⭐️若long类型的字面量没有超过int类型的取值范围，也不能直接编译成功，必须要进行强制类型转换；例如：int x = 10L（err）；int x = (int)10L(才正确)
⭐️例1
在java语言中整数型字面量有4种表示形式：十进制、二进制(0b)、八进制(0)、十六进制(0x)
public class IntTest01{
public static void main(String[] args){
//1.十进制
int a = 10;
System.out.println(a); // 10
//2.八进制，以0开头
int b = 010;
System.out.println(b); // 8
//3.十六进制，以0x开头
int c = 0x10;
System.out.println(c); // 16
//4.二进制方式，以0b开头；二进制（JDK8的新特性，低版本不支持）
int d = 0b10;
System.out.println(d); // 2
}
}⭐️例2：自动类型转换---小容量转换成大容量
1、重要的结论：在任何情况下，整数型的“字面量/数据”默认被当做int类型处理。
2、如果希望该“整数型字面量”被当做long类型来处理，需要在“字面量”后面添加L/l
public class IntTest02{
public static void main(String[] args){
//1.不存在类型转换
// 100这个字面量被默认当做int类型处理；
// a变量也是int类型，所以不存在类型的转换。
// int类型的字面量赋值给int类型的变量！
int a = 100;
System.out.println(a);
//2.存在类型转换（自动类型转换）
// 200这个字面量默认被当做int类型来处理；
// b变量是long类型，int类型占4个字节，long类型占8个字节
// 小容量可以自动转换成大容量，这种操作被称为：自动类型转换。
long b = 200;
System.out.println(b);
//3.不存在类型转换。
// 在整数型字面量300后面添加一个L之后，300L联合起来就是一个long类型的字面量
// c变量是也long类型，long类型赋值给long类型不存在类型转换。
long c = 300L;
System.out.println(c);
//4.存在类型转换（自动类型转换）
// 2147483647默认被当做int来处理
// d变量是long类型，小容量可以自动赋值给大容量，自动类型转换
long d = 2147483647; //2147483647是int最大值。
System.out.println(d);
//5.编译器会报错，为什么？
// 在java中，整数型字面量一上来编译器就会将它看做int类型
// 而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
// 不是e放不下2147483648，e是long类型，完全可以容纳2147483648
// 只不过2147483648本身已经超出了int范围。
long e = 2147483648;
System.out.println(e);// 错误: 整数太大，要想正常云运行，后面加上L即可
}
}⭐️例3：强制类型转换---大容量转小容量
1、小容量可以直接赋值给大容量，称为自动类型转换。
2、大容量不能直接赋值给小容量，需要使用强制类型转换符进行强转。
注意：加强制类型转换符之后，虽然编译通过了，但是运行的时候可能会损失精度
public class IntTest03{
public static void main(String[] args){
//1.不存在类型转换
// 100L是long类型字面量，x是long类型字面量。
long x = 100L;
//2.x是long类型，占用8个字节，而y变量是int类型，占用4个字节
// 编译错误信息：错误: 不兼容的类型: 从long转换到int可能会有损失
int y = x;//err
//3.大容量转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
//long类型100L：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
//会自动将“前面”的4个字节砍掉：00000000 00000000 00000000 01100100
int y = (int)x;
//4.这个(int)就是强制类型转换符，加上去就能编译通过。但是编译虽然过了，但是运行时可能损失精度。
System.out.println(y); // 100
}
}❤️byte类型和short类型
⭐️理解：若int类型的字面量没有超过char、byte和short类型的取值范围，就算不用强制类型转换也能正常编译；例如：byte x = 10(默认是int类型)、short y = 100(默认是int类型);
⭐️总结：当一个整数型的字面量没有超出 byte,short,char 的取值范围，可以将该字面量直接赋值给byte,short,char 类型的变量，如果超出范围则需要添加强制类型转换符。
⭐️特殊情况：例如：int x = 10，byte y = x还是会编译报错，因为编译器只能检测到右边是int类型，不知道具体字面量是多少；所以int类型数据用byte类型来存储就有可能缺失精度；所以会报错！
⭐️例1：
当这个整数型字面量没有超出当前变量的取值范围，那么这个整数型字面量可以直接赋值给当前类型的变量。
public class IntTest04{
public static void main(String[] args){
//1.300被默认当做int类型b变量是byte类型
// 大容量转换成小容量，要想编译通过，使用强制类型转换符
// 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte b = 300;//err，300超过了byte的范围
//2.要想让以上的程序编译通过，必须加强制类型转换符
//虽然编译通过了，但是可能精度损失。
// 00这个int类型对应的二进制：00000000 00000000 00000001 00101100
//byte占用1个字节，砍掉前3个字节，结果是：00101100 (44)
byte b = (byte)300;
System.out.println(b); // 44
//3.当整数型字面量没有超出byte类型取值范围的时候，该字面量可以直接赋值给short
byte x = 1;
byte y = 127;//默认都是int类型，的那都没有超过byte的取值范围，不会报错
//错误: 不兼容的类型: 从int转换到byte可能会有损失
byte z = 128;//超出byte的范围了，会编译报错
//4.当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short类型的变量。
short s = 1;
short s1 = 32767;
System.out.println(s);//正常输出
//错误: 不兼容的类型: 从int转换到short可能会有损失
short s2 = 32768;//err,超过short的取值范围
}
}⭐️例2：补充原码、反码、补码
10010110 ---> 二进制补码形式
10010101 ---> 二进制反码形式
11101010 ---> 二进制原码形式
public class IntTest05{
public static void main(String[] args){
//编译报错：因为150已经超出了byte取值范围，不能直接赋值，需要强转
//byte b = 150;//err
byte b = (byte)150;
//10010110，正数：原码、反码、补码同
//10010101，反码,补码-1就是反码
//11101010，原码，反码符号位不变，其它位取反
//或者可以直接用补码继续取反+1，10010110->11101001->11101010也能得到原码
//最高位是符号位，所以最终结果是：-1101010 = -106
System.out.println(b); // -106；也就是150-256=-106
}
}❤️byte、char、short混合运算
⭐️例1：
byte、char、short做混合运算的时候，各自先转换成int再做运算，最终结果就是int类型（相当于C语言中的整型提升）
public class IntTest06{
public static void main(String[] args){
//1.都会先转换为整型数据，然后在进行求和计算；最终结果也是整型
char c1 = 'a';
byte b = 1;
System.out.println(c1 + b); // 98
//2.错误: 不兼容的类型: 从int转换到short可能会有损失；这样为什么会报错呢？
//编译器不知道这个加法最后的结果是多少。只知道是int类型；所以可能会超过short范围，所以报错
//short s = c1 + b; //err
short s = (short)(c1 + b);//这样修改强制类型转化一下就可以了
//3.直接写成short x = 1可以；下面这种形式不可以，编译器只知道a是int类型，不知道a中存储的是哪个值。
//错误: 不兼容的类型: 从int转换到short可能会有损失
int a = 1;
short x = a;
System.out.println(x);//err，编译不过去
}
}⭐️例2：
1、多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型
2、char+short+byte 除外；char + short + byte混合运算的时候，会各自先转换成int再做运算；所以对应的最大容量就是int类型！
public class IntTest07{
public static void main(String[] args){
//1.最终结果的类型是long类型，提升到最大容量的类型
long a = 10L;
char c = 'a';
short s = 100;
int i = 30;
System.out.println(a + c + s + i); //237，结果是long类型
//2.要想用int接收，必须强制类型转换；计算结果是long类型
//错误: 不兼容的类型: 从long转换到int可能会有损失
//int x = a + c + s + i;//err
int x = (int)(a + c + s + i);//强制类型转换
System.out.println(x);
}
}🥅浮点型类型：float、double
⭐️例1：
1、浮点型包括：float是单精度占4个字节；double是双精度占8个字节；
2、注意：如果用在银行方面或者说使用在财务方面，double也是远远不够的，在java中提供了一种精度更高的类型，这种类型专门使用在财务软件方面：java.math.BigDecimal （不是基本数据类型，属于引用数据类型）
3、float和double存储数据的时候都是存储的近似值。
4、long类型占用8个字节，float类型占用4个字节；哪个容量大？
注意：任意一个浮点型都比整数型空间大；float容量 > long容量。
5、java中规定，任何一个浮点型数据默认被当做double来处理。如果想让这个浮点型字面量被当做float类型来处理，在字面量后面添加F/f。6、如果想要得到一个float类型 的浮点数，必须要强制类型转换或者在数据后面加上F/f才可以，不然就会编译报错！不是像byte、short、char类型一样，默认数据是int类型，数据只要没超过byte、short、char类型范围，就能直接赋值过去！
public class FloatTest01{
public static void main(String[] args){
//1.这个不存在类型转换，3.1415926是double类型，pi是double类型
double pi = 3.1415926;//默认是double类型
System.out.println(pi);
//2.错误: 不兼容的类型: 从double转换到float可能会有损失
float f = 3.14;
//修改方法1：3.14f或者3.14F
//修改方法2：强制类型转换，但可能损失精度。谨慎使用。
float f = (float)3.14;
System.out.println(f);
//3.错误: 不兼容的类型: 从double转换到int可能会有损失
//原理：先将5转换成double类型，然后再做运算，结果是double，大容量无法直接赋值给小容量，需要强转。
int i = 10.0 / 5; // err
//修改方法1：
int i = (int)10.0 / 5;
System.out.println(i); // 2
//修改方法2：
int x = (int)(10.0 / 5);
System.out.println(x); // 2
}
}🥅布尔型类型：boolean
⭐️例1：
1、在java语言中boolean类型只有两个值，没有其他值：true和false。
不像C或者C++，C语言中1和0也可以表示布尔类型。
2、boolean类型在实际开发中使用在逻辑判断当中，通常放到条件的位置上（充当条件）
public class BooleanTest01{
public static void main(String[] args){
//1.错误: 不兼容的类型: int无法转换为boolean
//boolean xingBie = 1;//1并不能代表true
//2.如果为true则表示男，为false则表示女。
boolean sex = true;
if(sex){
System.out.println("男");
}else{
System.out.println("女");
}
//3.判断大小，输出的是true或false；而不是1或0
int a = 10;
int b = 20;
System.out.println(a < b); // true
System.out.println(a > b); // false
}
}总结：
⭐️八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
⭐️如果整数型字面量int没有超出 byte、short、char 的取值范围，可以直接将其赋值给
byte、short、char 类型的变量；
⭐️小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) <
int < long < float < double，其中 short 和 char 都占用两个字节，但是 char 可以表示更大
的正整数；
⭐️大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；
⭐️byte、short、char 类型混合运算时，先各自转换成 int 类型再做运算；
⭐️多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；
🥅小试牛刀
⭐️例1
public class TypeTransferTest{
public static void main(String[] args){
//1.编译报错，因为1000已经超出byte的范围(-128~127)了
byte b1 = 1000;
//2.可以
byte b2 = 20;
//3.可以
short s = 1000;
//4.可以
int c = 1000;
//5.可以
long d = c;
//6.编译报错，d是long型，放到int型需要强制类型转换
//int e = d;
int e = (int)d;
//7.可以
int f = 10 / 3;
//8.可以
long g = 10;
//9.编译报错，g是long型，最终结果也是long型，放到int型需要强制类型转换
//int h = g / 3;
int h = (int) (g / 3);
//10.可以
long m = g / 3;
//11.编译报错，g虽然强制类型转换了，但是3还是整型，最终结果就是整型，放到byte需要强制类型转换
//byte x = (byte)g / 3;
byte x = (byte)(g / 3);
//12.可以
short y = (short)(g / 3);
//13.可以
short i = 10;
//14.可以
byte j = 5;
//15.编译报错，只能检测出i+j结果是整型，整型放到short来接收，会编译报错
//short k = i + j;//这里换成15就可以的
//16.可以
int n = i + j;
//17.可以
char cc = 'a';
System.out.println(cc); // a
//最终结果强制类型转换为byte，属于整型，结果也没有超出byte的范围，结果是97
System.out.println((byte)cc); //97
//18.cc会先自动转换成int类型，也就是97，最后再做运算
int o = cc + 100;
System.out.println(o); // 197
}
}⭐️例2：short s1 = 1 和 s1 = s1 + 1有什么错？
s1 是 short 类型，1 是 int 类型，short 和 int 混合运算的时候 short 会自动转换为 int 类型， 所以 s1 + 1 编译器检测出是 int 类型，int 类型无法赋值给 short 类型的变量 s1。这样修改：s1 = (short)(s1 + 1);
⭐️例3：char 类型变量能不能储存一个中文的汉字，为什么？
java 中的文字采用 unicode 编码，一个中文占用 2 个字节，char 类型在 java 中就是占用两个字节，所以 java 中的 char 类型完全可以容纳一个汉字。
⭐️例4：float f = 1.0 有什么错？
1.0 字面量被当做 double 类型处理，大容量 double 无法赋值给小容量 float；两 种方案：
第一种方案是 1.0 后面添加 f/F。
第二种方案是强制类型转换：float f = (float)1.0。
⭐️例5：long a = 2147483648 有什么错？
不是 long 类型存不下 2147483648，而是 java 把 2147483648 当做 int 类型来处理，但本身 已经超出 int 类型范围，所以会报错；这样修改：long a = 2147483648L;
⭐️例6：int i = 0xffff 有问题吗？
没有问题：0xffff 以 0x 开始表示十六进制表示方式，ffff 转换成二进制是1111 1111 1111 1111
也就是
，也可以就理解为十六进制，也就是
，结果就是：65535；没有超出整型数据的范围[-2147483648 ~ 2147483647]
⭐️例7：char c = 65536 有问题吗，为什么？
65536 已经超出 char 类型取值范围，不能直接赋值，需要强制类型转换：char c = (char)65536;
总结常用的范围：
①byte范围是：-128到127
②short：-32768到32767
③char范围是：0到65535
④int范围是：-2147483648到2147483647
扫一扫
9009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
