Java零基础之Java中的数据类型

---

前言

本篇博客主要介绍Java语言中的数据类型

---

一、变量和类型

在学习数据类型之前，我们需要先了解变量和类型的概念。Java和C++都属于强类型的语言，定义一个变量时，必须指定这个变量的类型，这个变量在之后的赋值中，只能赋值为相应类型的值。

变量

变量指的是程序运行时可变的量，可以人为的赋予或修改其数值，它是是一个有名字的，具有特定属性的一个存储单元。本质上来说，变量代表了一段可操作的内存，当程序中需要使用内存时，可以定义某种类型的变量，编译器会根据变量的数据类型分配一定大小的内存空间，程序通过变量名来访问对应的内存。

类型

类型则是对变量的种类进行了划分, 不同的类型的变量具有不同的特性，不同类型的数据占用空间大小不同。类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。

二、八种基本数据类型

1.整型变量（int）

基本语法格式

int 变量名 = 初始值

代码实例

//此时声明一个变量，它的类型为int，并且初始化变量a的值为10
int num = 10;
System.out.println(num) ;

注意

1. int 表示变量的类型是一个整型
2. 变量名是变量的标识. 后续都是通过这个名字来使用变量
3. Java 中 “=” 表示赋值(和数学不一样), 意思是给变量设置一个初始值
4. 初始化操作是可选的, 但是建议创建变量的时候都显式初始化.

在 Java 中, 一个 int 变量占 4 个字节和操作系统没有直接关系。那么什么是字节呢？
字节是计算机中表示空间大小的基本单位，计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).

1 byte = 8 bit

4 个字节表示的数据范围是 -2^31 -> 2^31-1 , 也就大概是 -21亿 到 +21亿。如果运算的结果超出了 int 的最大范围, 就会出现溢出的情况.
21亿这样的数字对于当前的大数据时代来说, 是很容易超出的， 针对这种情况, 我们就需要使用更大范围的数据类型来表示了Java 中提供了long类型。

2.长整型变量(long)

基本语法格式

long 变量名 = 初始值;

代码实例

// 定义一个长整型变量, 初始值写作10l也可以(小写的L,不是数字1). 
long num = 10L; 
System.out.println(num);

注意

1. 基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long
2. 初始化设定的值为 10L , 表示一个长整型的数字. 10l 也可以
3. 使用10初始化也可以, 10的类型是int, 10L的类型是long, 使用10L或者 10l更好一些

Java 中 long 类型占 8 个字节. 表示的数据范围 -2^63 -> 2^63-1，这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用。

3.双精度浮点型变量(double)

基本语法格式

double 变量名 = 初始值;

代码示例

double num = 1.0;
System.out.println(num);

在Java中直接写出来的小数就是double类型的，浮点数字面值默认类型为double。
注意：

int a = 1;
int b = 2;
System.out.println(a / b);
// 执行结果
0

在Java中, int除以int 的值仍然是int(会直接舍弃小数部分)；如果想得到 0.5, 需要使用 double 类型计算：

double a = 1.0;
double b = 2.0;
System.out.println(a / b);
// 执行结果
0.5

注意：

double num = 1.1;
System.out.println(num * num)
    
// 执行结果
1.2100000000000002

Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围，Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差.

在工程中中一般有以下两种解决方法：

1.仍然使用double，但是我们一般只看小数点后6位左右为有效位数。
2.使用BigDecimal类来代替double使用。

4.单精度浮点型变量(float)

基本语法格式

float 变量名 = 初始值;

代码示例

float num = 1.0f;    // 写作 1.0F 也可以
System.out.println(num);

float 类型在 Java 中占四个字节, 同样遵守IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用float。

5.字符类型变量(char)

基本语法格式

char 变量名 = 初始值;

代码示例

char ch = 'A';
char ch = '呵'; 

字符型变量为2字节，无论是英语，中文，日语。还是俄语，只要是字符型变量，都是2字节。Java中字符集默认为Unicode编码，支持地球上所有的语言。
注意：执行 javac 的时候可能出现以下错误:

Test.java:3: 错误: 未结束的字符文字
 char ch = '鍛?'; 

此时我们在执行 javac 时加上 -encoding UTF-8 选项即可

javac -encoding UTF-8 Test.java 

6.字节类型变量(byte)

基本语法格式

byte 变量名 = 初始值;

代码示例:

byte value = 0; 
System.out.println(value);

注意：

1. 字节类型表示的也是整数. 只占一个字节, 表示范围较小 [-128,127]，一般用在文件和网络传输中
2. 字节类型和字符类型互不相干

7.短整型变量(short)

基本语法格式

short 变量名 = 初始值;

代码示例:

short value = 0; 
System.out.println(value); 

注意：

1. short 占用 2 个字节, 表示的数据范围是 [-32768,+32767]
2. 这个表示范围比较小, 一般不推荐使用.

8.布尔类型变量(boolean)

基本语法格式

boolean 变量名 = 初始值;

代码示例:

boolean value = true; 
System.out.println(value);

注意：

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假，与数字0和1没有任何关系
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.

三、引用数据类型

引用数据类型目前只讲解学习一个，即字符串类型变量。

字符串类型变量(String)

把一些字符放到一起就构成了字符串

基本语法格式

String 变量名 = “初始值”;

代码示例:

String name = "zhangsan"; 
System.out.println(name);

Java 使用 双引号 + 若干字符 的方式表示字符串字面值.
字符串中的一些特定的不太方便直接表示的字符需要进行转义.
当碰到一些特殊字符时，需要转义输出，所谓的转移输出，就是告诉编译器，对这个字符不要做特殊处理。

// 创建一个字符串 My name is "张三"
String name = "My name is \"张三\"";

转义字符：

转义字符	解释
\n	换行
\t	水平制表符
\’	单引号
\"	双引号
\	反斜杠

字符串的 + 操作, 表示字符串拼接：

String a = "hello"; 
String b = "world"; 
String c = a + b; 
System.out.println(c); 

//运行结果
helloworld

还可以用字符串和整数进行拼接:

String str = "result = "; 
int a = 10; 
int b = 20; 
String result = str + a + b; 
System.out.println(result); 
// 执行结果
result = 1020 

以上代码说明, 当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为，因此我们可以很方便的使用 System.out.println 同时打印多个字符串或数字

int a = 10; 
int b = 20; 
System.out.println("a = " + a + ",b = " + b);

四、变量的作用域

也就是该变量能生效的范围，一般是变量定义所在的代码块(大括号)

public class Test01 {
   public static void main(String[] args){
         int a = 10;
         int b = 20;
   }
}

a和b是在主方法{}中定义的，因此在主方法的内部都是可以使用的，出了主方法，a和b就会被销毁。

class Test02 { 
 public static void main(String[] args) { 
 { 
 int x = 10; 
 System.out.println(x); // 编译通过; 
 } 
 System.out.println(x); // 编译失败, 找不到变量 x. 
 } 
}

五、变量的命名规则

硬性指标:

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. 变量名是大小写敏感的，即 num 和 Num 是两个不同的变量. 注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是强烈不建议这样做。

软性指标:

1. 变量命名要具有描述性, 见名知意.
2. 变量名不宜使用拼音(但是不绝对).
3. 变量名的词性推荐使用名词.
4. 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.

小驼峰命名示例:

int maxValue = 100; 
String studentName = "张三";

六、常量

1.字面值常量

直接写出来的值，都叫字面量

— 10，100 属于整数型字面值
— 3.14 属于浮点型字面值
— true，false 属于布尔型字面值
— ”abc“，”中国人“ 属于字符串型字面值
— ‘a’,‘人’ 属于字符型字面值

2. final 关键字修饰的常量

若程序中有些属性不能修改，称这些属性为常量，定义之后值无法修改，定义常量使用final关键字。

final int a = 10; 
a = 20; // 编译出错. 提示 无法为最终变量a分配值

常量不能在程序运行过程中发生修改。

七、Java中的类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有较严格的校验。

一、小类型转为大类型是自动提升的

1.1 小类型的变量值赋值给大类型时

//20是一个整型，int型赋予long型时，会自动提升为long型
long b = 20;

int a = 10; 
long b = 20; 

//long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 

//double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int.
int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 

结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行。

1.2 小类型和大类型进行数学运算时，首先会将小类型提升为大类型而后进行数学运算

int a = 10;
long b = a + 1L; // int+long=>long+long

int a = 10; 
long b = 20; 
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过

当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换。

int c = (long)a + b;

二、大类型转为小类型需要强制类型转换，可能会丢失精度。(数据溢出或者数据部分丢失)

int a = 0; 
double b = 10.5; 
a = (int)b;

注意：

int a = Integer.Max_VALUE;
long b = a + 1;
System.out.println(b);

//运行结果
-2147483648

程序执行代码都是从右向左执行，先进行的时a+1，此时已经溢出了，并不是long b放不下，而是存储了一个溢出的值。

三、int和byte之间的转换

对于数值型和字符型来说，小于4字节的数据类型，在存储时会转为4字节。byte类型在保存时会转为int类型。
当把byte类型保存区间之内的整数赋值给byte时，可以直接赋值，超出byte的范围仍然需要强制类型转换。

byte a = 120;//没有超出范围，可以直接赋值
byte b = 130;//超出范围，编译报错
//java: 不兼容的类型: 从int转换到byte可能会有损失
byte b = (byte)130;

当把一个int变量赋值给byte时，无论是否超出保存范围，都需要强转

int a = 120;
byte b = a;//java: 不兼容的类型: 从int转换到byte可能会有损失

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;

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

注意：被final修饰的变量除了数据值不能改，类型也不能提升

final byte a = 10;
final byte b = 20;
//存储时仍然是byte类型
byte c = a + b;

int和char之间的相互转换

计算机的内部都是0和1，char字符会按照不同的编码规则转为int存储。

char a = 'a';
int b = a;//char-->int自动提升，按照Unicode编码将'a'转为int
char c = 'A';
int d = c;

//编译结果
97
65

int a = 97;
char b = (char)a;
System.out.println(b);

//编译结果
a

int和String之间的相互转换
1.int–>String

int num = 10; 
// 方法1：直接String对象+
String str1 = num + ""; 
// 方法2 ：使用String的valueOf方法
String str2 = String.valueOf(num);

2.String 转成 int

String str = "100"; 
//调用int包装类Integer.parseInt方法
int num = Integer.parseInt(str); 

八、数据类型的默认值

在Java中，所有数据类型都有默认值，定义之后没有赋值，会有默认值（只存在于类变量之中，方法中的局部变量不存在默认值）

数据类型	默认值
byte，short，int ，long	0
float,double	0.0
boolean	false
char	\u0000
String	null

总结

以上就是今天要讲的内容,每种数据类型及其范围, 是需要我们掌握的重点。隐式类型转换和类型提升, 是本节的难点.。但是一般我们更推荐在代码中避免不同类型混用的情况, 来规避类型转换和类型提升的问题.