Java数据类型与变量
字面常量
字面常量就是程序运行期间，固定不变的量。比如一周7天，一年12个月。
字面常量的分类
字符串常量：由 “” 括起来的，比如"1234", “hello”, “冲冲冲”
整型常量：程序中直接写的整数数字（没有小数点），如1234、100
浮点数常量：程序中直接写的小数，比如3.14，0.1314
字符常量：由单引号括起来的单个字符，如’a’, ‘N’, ‘M’
布尔常量：只有两种，true 和 false
空常量：null
数据类型
在java中数据类型分为两类，基本数据类型和引用数据类型
基本数据类型
分为四类八种
整型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean
注意：
- 无论是16位系统还是32位系统，int都占用4个字节，long都占用了8个字节。
- 整型和浮点型都是带符号的
- 整型默认为int型，浮点型默认为double
- 不论是多少位系统，java中都数据类型占用的字节数都是一定的。优点：可移植性高
引用数据类型
字符串（String），数组，接口、类都是引用数据类型，后续我们会继续了解。
变量
在程序中除了固定不变的常量，还有经常改变的变量，如年龄、身高等等，我们把在程序中经常改变的内容，称为变量，数据类型就是用来修饰不同种类的变量。
语法格式：
数据类型 变量名 = 初始值；
变量的定义和初始化
public class Test {
public static void main(String[] args) {
//方式一：在定义时给出初始值（推荐）
int a = 10;//a是变量，a的值是可以修改的，= 在java中表示赋值
int a1 = 2, a2 = 3, a3 = 5;//一行可以定义多个相同类型的变量
//方式二：在定义时没有给初始值，但使用前必须设置初始值
int b;
b = 10;
System.out.println(b);
//使用方式二如果没有给出赋值，则编译期间会报错
int c;
System.out.println(c);
}
}
整型变量
整型变量
public static void main(String[] args) {
System.out.print("整型表示的最小值：");
System.out.println(Integer.MIN_VALUE);
System.out.print("整型表示的最大值：");
System.out.println(Integer.MAX_VALUE);
}
- Integer是int的包装类，我们可以先理解是int的plus版本，里面包含更多的方法，方便程序员使用，后续我们会继续介绍。
- int不论在任何系统下都是4个字节。（整型是有符号位，所以表示数值的位数是31位）（-231 ~ 231 - 1）(因为其中还要表示0这个数，所以最大值-1)
- 如果在进行变量赋值的时候，字面值超过了可存储的范围，编译会报错。
public static void main(String[] args) {
int a = 1121474836499;//此时已经超过最大值2147483647
System.out.println(a);
}
长整型变量
public static void main(String[] args) {
long a = 100;//long定义的长整型变量
long b = 100L;//为了区分long和int类型，建议在long类型变量的初始值之后加 l 或 L
long c = 100l;//一般加L，因为小写l与1不好区分
}
public static void main(String[] args) {
System.out.print("长整型表示的最小值：");
System.out.println(Long.MIN_VALUE);
System.out.print("长整型表示的最大值：");
System.out.println(Long.MAX_VALUE);
}
long的包装类是Long
不论是哪位系统下，长整型都表示8个字节。 (长整型是有符号位，所以表示数值的位数是63位）（-263 ~ 2 63 - 1）(因为其中还要表示0这个数，所以最大值-1)
短整型变量
public static void main(String[] args) {
short a = 10;
System.out.println(a);
System.out.print("短整型表示的最小值：");
System.out.println(Short.MIN_VALUE);
System.out.print("短整型表示的最大值：");
System.out.println(Short.MAX_VALUE);
}
Short是short的包装类
不论是哪位系统下，短整型都表示2个字节。 (短整型是有符号位，所以表示数值的位数是15位）（-215 ~ 2 15 - 1）(因为其中还要表示0这个数，所以最大值-1)
字节型变量
public static void main(String[] args) {
byte a = 10;
System.out.println(a);
System.out.print("字节型表示的最小值：");
System.out.println(Byte.MIN_VALUE);
System.out.print("字节型表示的最大值：");
System.out.println(Byte.MAX_VALUE);
}
byte的包装类是Byte
不论是哪位系统下，字节型都表示1个字节。 (字节型是有符号位，所以表示数值的位数是7位）（-27 ~ 2 7 - 1）(因为其中还要表示0这个数，所以最大值-1)
浮点型变量
双精度浮点型变量
public static void main(String[] args) {
double d = 1.2;
System.out.println(d);
}
double的包装类是Double
浮点数与整数在内存中存储方式不同，不能单纯用2n的形式来计算
double在任何系统都是占8个字节
double类型的内存遵守IEEE 754标准（和C语言一样），尝试使用有限的空间表示可能无限的小数，势必存在一定的精度误差，因此浮点数是个近似值，并不是精确值。
如果想更加深刻的理解，可以去我往期的文章中查看: 数据在内存中的存储
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.print("（int）a / (int) b = ");
System.out.println(a / b);//int / int 仍然是 int， 所以小数部分会被舍弃
double c = 1.0;
double d = 2.0;
System.out.print("（double）c / (double) d = ");//double / double 仍然是 double， 所以小数部分依然存在
System.out.println(c / d);
}
public static void main(String[] args) {
double a = 1.1;//会输出1.21吗
System.out.println(a * a);//存在精度误差，小数是不能精确到小数的每一位，只能精确表示小数点后几位
}
单精度浮点数
public static void main(String[] args) {
float a = 1.5F;
float b = 1.5f;
System.out.println(a);
System.out.println(b);
}
float类型在java中占4个字节，同样遵守IEEE 754标准。由于表示的数据精度范围比较小，一般在工程上用到浮点数都优先考虑double
float的包装类是Float
public static void main(String[] args) {
float a = 1.5;//此时编译器会报错，因为浮点数默认是double类型，double是8个字节，
// 而float是4个字节，此时会发生截断，精度丢失，所以编译器报错,
// 所以单精度浮点数所附的值后加 F 或 f
System.out.println(a);
}
字符型变量
public static void main(String[] args) {
char c1 = 'A';
char c2 = '1';
//注意：java中的字符可以存放整型,可以存放中文
char c3 = '冲';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
}
java中使用单引号+单个字母的形式表示字符字面值
计算机中的字符本质上是一个整数，在C语言中使用ASCII码表示字符，而java中使用unicode表示字符，因此一个字符占用两个字节（0~65535），表示的字符种类更多，包括中文。
char的包装类是Character
布尔型变量
public static void main(String[] args) {
boolean a = true;
System.out.println(a);
boolean b = false;
System.out.println(b);
}
- 并没有明确说明boolean是多少字节
- boolean类型的变量只有两种取值，true表示真，false表示假
- java的 boolean 类型不能与 int 类型相互转换，不存在 1表示真，0表示假这样的用法
- boolean的包装类是Boolean
类型转换
java作为一个强类型编程语言，当不同类型的变量之间相互赋值时，会有比较严格的校验
public static void main(String[] args) {
int a = 10;
long b = 100L;
//以下两条语句都需要类型转换
b = a;//可以通过编译
a = b;//编译报错
}
在java中，当参与运算数据类型不一致时，就会进行类型转换，java中类型转换主要分为两类：自动类型转换（隐式）和强制类型转换（显式）。
自动类型转换（隐式）
自动类型转换就是代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
特点：数据范围小的的转换为数据范围大的自动转换
public static void main(String[] args) {
int a = 10;
long b = 100L;
b = a;//a 是 int ， b 是 long ，a 的范围小赋值给 b （范围大），会将a自动提升为long，然后赋值
a = b;//long的范围比int的范围大，会有数据丢失，不安全，所以会报错，不会自动转换
System.out.println(3);//默认情况下类型为整型
System.out.println(3.14);//默认情况下类型为double
}
强制类型转换（显式）
强制类型转换：当进行操作时，代码需要经过一定的格式处理，否则会编译失败。
public static void main(String[] args) {
int a = 10;
long b = 100L;
b = a;//int -> long 数据范围小的向数据范围大的转换，隐式转换
a = (int)b;//long -> int 数据范围大的向数据范围小的转换，需要强转，否则编译报错
boolean flag = true;
a = flag;//编译失败，类型不兼容，int与boolean不可以相互转换
}
注意：
- 不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型
- 如果需要把范围大的类型赋值给范围小的，需要强制类型转换，但是可能精度丢失
- 将一个字面值常量进行赋值的时候，java会自动针对数字范围进行检查
- 强转类型转换不一定能成功，不相干的类型不能相互转换
类型提升
不同类型的数据之间相互运算，数据类型小的会被提升到数据类型大的
- int 与 long 之间： int会被提升为long
public static void main(String[] args) {
int a = 10;
long b = 20;
int c= a + b;//编译失败：int会被提升为long，long + long = long
// 结果long类型转换为int，数据范围大的转换成小的，数据丢失，不安全
long d = a + b; // 编译成功
}
- byte 与 byte 的运算
public static void main(String[] args) {
byte a = 10;
byte b = 20;
byte c = a + b;//编译报错，int转换为byte，数据丢失，不安全
int d = a + b;//通过编译
byte e = (byte)(a + b);//通过编译
}
结论： byte和byte都是相同类型，但是出现编译报错，原因是：虽然a和b都是byte，但是计算 a+b 会先将a和b都提升为int，再进行计算，得到的结果也是int，此时赋给c，就会出现上述错误。
由于计算机的CPU通常是按照4个字节为单位从内存中读写数据。为了硬件上实现方便，诸如byte和short这种低于4个字节的类型，会先提升成int，再参与计算。
—————————————————————————————————————这篇文章到此就先结束了，对引用数据类型或许还有很多疑问，我们后面继续一起了解和学习。
扫一扫
2941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
