Java的数据类型

---

前言

Java是一种非常优美的计算机程序设计语言，因为它的代码结构总是令人赏心悦目。它是面向对象的，在Java中，一切皆对象。而且，Java还是“一处编译，多处执行”的语言。那么在学习Java的过程中，我们先来了解了解Java中的数据类型。

---

`

一、数据类型结构

如图，

Java的数据类型可分为基本数据类型和引用数据类型

1.基本数据类型

Java中有八大基本数据类型

整型

整型分为byte、short、int、long四类

1. byte（字节型）
   （1） 字节类型的变量表示的是一个整数，它只占一个字节，也就是八位。表示的范围是[-128~127]。
   （2）byte在Java学习中很少用到。但是在实际业务开发中经常用到，在项目开发中都会牵扯到字节流的使用。所以byte很重要。
2. short(短整型)
   short占两字节，十六位，表示的范围为[-2^15 ~ 2^15-1]，表示的范围非常小。所以很少用到short，也不推荐使用。
3. int（整型）
   （1）int占四字节，三十二位，表示的范围是[-2^31 ~ 2^31-1]，大概是-21亿到21亿这个范围，在工程中很多情况都超出了这个范围。但是在学习环节经常用到int。
   （2）使用Java中int的包装类Integer提供的方法Integer.MAX_VALUE和Integer.MIN_VALUE，可以查看int类型的范围：

public class Test {
    public static void main(String[] args) {
        System.out.println("int的最大值：" + Integer.MAX_VALUE);
        System.out.println("int的最小值：" + Integer.MIN_VALUE);
    }
}

4. long（长整型）
（1）在现在的大数据时代，long类型基本可以适用于绝大多数工程。long占八字节，六十四位。表示的范围为[-2^63 ~ 2^63-1]。
（2）在定义long类型变量时，最好是在初始值的后面加一个大写的L。（方便阅读者辨认）
例如：long a = 10L;
（3）同样也可以使用long的包装类Long，查看long的范围。

public class Test {
    public static void main(String[] args) {
        System.out.println("long的最大值：" + Long.MAX_VALUE);
        System.out.println("long的最小值：" + Long.MIN_VALUE);
    }
}

浮点型

5. float（单精度浮点数）
   （1）float类型在Java中占四个字节，遵循IEEE754标准。因为它可以表示小数部分，所以它表示的数是要多于int。
   （2）在使用float给变量命名时，通常在给变量赋的值后面加上F或f，表示这是一个float类型的变量。
   例如：float a = 1.1f;或者float a = 1.1F;
   （3）由于float表示的范围较小，所以在工程中，不会使用float。
6. double（双精度浮点数）
   （1）double类型在Java中占八字节，同样遵循IEEE754标准，也同样它表示的数量远大于long，不能单纯用2的多少次方去表示它的范围。
   （2）工程中同样经常使用double类型。

字符型

7. char
   （1）计算机中字符的本质是一个整数，在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
   （2）在Java中使用单引号+单个字母的形式表示字符型变量。例如：char ch = 'A'
   （3）注意：字符类型和字节类型互不相干。

布尔型

8. boolean
   （1）boolean 类型的变量只有两种取值, true 表示真, false 表示假。
   例如：boolean value = true;或boolean value = false;
   （2） Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
   （3）boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定。

2.引用数据类型

类（class）

Java中一切皆对象，所以，所有方法和变量都定义在一个类中。在Java的学习过程中，会接触到各种各样的类。这里我们重点理解一下String类型，也就是字符串这个类。
（1） Java 使用 双引号 + 若干字符 的方式表示字符串字面值。
例如：String str = "zhangsan";
（2）字符串中的一些特定的不太方便直接表示的字符需要进行转义。
例如：String name = "my name is \"张三\" ";
（3）注意，在声明字符串变量时，Sting的首字母"S"大写，否则报错。

接口（interface）

Java接口是一系列方法的声明，是一些方法特征的集合。接口在工程中会经常用到。后期，会详细讨论。

数组（[ ]）

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。在Java中，数组通常有如下定义：

int size = 10;
int[] arr = new int[size]; 

后期，也会详细讨论数组。

---

二、基础概念及注意点

1.变量和常量

1. 变量
   （1）概念：变量指的是程序运行时可变的量. 相当于开辟一块内存空间来保存一些数据。
   （2）定义的数据类型，就是对变量的种类进行划分。
   （3）变量的作用域，也就是该变量能生效的范围，一般变量定义所在的代码块（大括号中）。注意，定义在方法中的变量叫局部变量，只在方法中生效，而且必须初始化（赋值操作）；定义在类中的变量，叫做全局变量，也称成员变量，就是在整个类中都有效，可以不用赋初始值。
   （4）所有类型变量的定义格式：类型 变量名 = 初始值;
2. 常量
   （1）字面值常量

   常量值	说明
   10	int 字面值常量(十进制)
   010	int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8
   0x10	int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16
   10L	long 字面值常量. 也可以写作 10l (小写的L)
   1.0	double 字面值常量. 也可以写作 1.0d 或者 1.0D
   1.5e2	double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2
   1.0f	float 字面值常量, 也可以写作 1.0F
   true	boolen 字面值常量, 同样的还有 false
   ‘a’	char 字面值常量, 单引号中只能有一个字符
   “abc”	String 字面值常量, 双引号中可以有多个字符

（2）final关键字修饰的常量
例如：

final int a = 10;
a = 20;     //这里编译出错，提示不能为最终的变量a分配值

final修饰的变量不能被改变。
注意，常量不能在程序运行过程中发生修改。
关于，final关键字，后期也会重点讨论，这里只是简单介绍一下。

2.命名规则

1. 变量的命名规则
   硬性指标
   （1）一个变量名只能包含数字, 字母, 下划线。
   （2）数字不能开头。
   （3）变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量。
   注意，虽然语法上也允许使用中文/美元符($)命名变量, 但是 强烈 不推荐这样做。
   软性指标
   （1）变量命名要具有描述性, 见名知意。
   （2）变量名不宜使用拼音(但是不绝对)。
   （3）变量名的词性推荐使用名词。
   （4）变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写。
   例如：int maxValue = 100; String studentName = "张三";

2. 类的命名规则
   大驼峰命名法，就是从第一个单词开始首字母大写，例如：public class Person{}或者public class PressNunmber{}

3. 项目的命名规则
   全小写，多个单词用下划线_分割，例如：five_chess_game

3.类型转换

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

1. int和long/double相互赋值
   有如下场景：

int a = 10; 
long b = 20; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 
int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过

因为：
long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int；
double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int。
所以，得到如下结论
（1）小类型转换到大类型时，涉及到运算，会自动提升。
（2）大类型转换到小类型时，需要强制类型转换，会有丢失精度的风险。

2. int和boolean相互赋值

int a = 10; 
boolean b = true; 
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

很明显，int和boolean是毫不相干的两种类型，不能相互赋值。

3. int字面值常量赋值给byte

byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失
byte c = (byte)256;//使用强制类型转换，编译可以通过，但是没有任何意义，因为byte的范围只有-128~127

4. int和char的转换

char ch = (char) 97; //编译通过，输出结果为97，因为char类型本来就表示为一个整数

int类型可以强转为char类型。对应为相应的ASCII码。

4.数值提升

1. int和long混合运算

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

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

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变量之间的运算时，JVM内部会将byte提升为int，进行运算。所以正确写法为：

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

结论：
（1）不同类型进行数值运算时，范围小的会自动提升为范围大的。
（2）由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算。

5.精度丢失问题

我们刚才说了，大类型到小类型时，会出现精度丢失问题，那么，如何解决这个问题呢，下面，我们以int和double为例，来讨论。
我们先来看一段下面的代码：

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a/b);  //输出结果为0，因为同类型的变量进行运算，得到的结果也是这个类型
    }
}

改一下，把其中一个变量改为double类型，就可以得到想要的结果了

 int a = 1;
 double b = 2.0; //把变量b的类型改为double类型
 System.out.println(a/b); //得到想要的结果0.5

我们再来看看下面这一段代码，看看结果是啥：

public class Test {
    public static void main(String[] args) {
        double a = 1.1;
        double b = 1.1;
        System.out.println(a*b);
    }
}

咦！神不神奇，结果应该是1.21才对的吧，那为啥多了这么多位02？
原因是，在Java虚拟机中，数值计算都是以二进制形式进行计算的。通常二进制位表示的都是整数部分，但是小数部分只是用二进制进行模拟的，当小数部分位数超出一定范围时，就不能被完全模拟表示出来，所以就会出现精度丢失的情况。
这时，我们就可以使用Java提供的BigDecimal这个类来解决精度丢失的问题。代码如下：

public class Test {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.1");
        BigDecimal b = new BigDecimal("1.1");
        BigDecimal c = a.multiply(b);
        System.out.println(c.doubleValue());
    }
}

这样就可以得到我们想要的结果了。

6.溢出问题

当我们给个变量赋的值，超出了这个变量的类型范围，就会发生溢出，我这里以int为例，进行讨论：

int a = Integer.MAX_VALUE + 1;
int b = Integer.MIN_VALUE - 1;
System.out.println(a);
System.out.println(b);

嘿嘿，可以发现，当我们给int的最大值加一时，得到的正好是int的最小值；给int的最小值减一时，的得到的正好是int的最大值。因为这其中的运算存在二进制反码和补码转换的问题。

7.String类型和其他类型的转换

String（字符串）和其他类型的转换问题，是所有程序员在初学计算机编程语言时，必须要掌握的最基本的知识。任何时候，只要是做软件或系统开发，有输入输出的交互，都要有用到字符串，必然离不开字符串的转换。我们用户在使用软件产品时，用户进行输入，后台拿到的数据，默认的都是字符串。这里，我以String和int之间的转换为例来展开讨论

1. int转换为String
   （1）最简单，最直接的操作就是，使用“+”与int类型变量做拼接操作。任何类型转换为String类型，都可以使用“+”进行拼接。

public class Test {
    public static void main(String[] args) {
        int a  = 123;
        String str = 4 + "" + a;
        System.out.println(str);
    }
}

（2）使用String类提供的方法String.valueOf()

public class Test {
    public static void main(String[] args) {
        int a  = 123;
        String str = String.valueOf(a);
        System.out.println(4 + str);
    }
}

2. String转换为int
（1）这里，我们使用int包装类Integer提供的方法Integer.parseInt()将String类型的变量转换为int类型的。

public class Test {
    public static void main(String[] args) {
        String s = "123";
        int a = Integer.parseInt(s);
        System.out.println(a+1);
    }
}

（2）下面，我们再来看一个代码

public class Test {
    public static void main(String[] args) {
        String s = "123a";     //注意，我这里给s加了个a，把s改成了一个非纯数字的字符串
        int a = Integer.parseInt(s);
        System.out.println(a+1);
    }
}

编译没有出错，但是运行时间出错了，数字格式转换异常：

结论，把非纯数字的String变量转换为int，出错。

8.默认值

数据类型都是有默认值的。
基本数据类型

1. 整型的默认值是0
2. 浮点型的默认值是0.0
3. 字符型char的默认值是\u0000（空格）
4. 布尔型boolean的默认值是false

引用数据类型
引用数据类型的默认值都为null

---

总结

以上内容，就是关于Java的数据类型以及相关基本概念的详细阐述。非常基础，也非常重要。希望对初学者或者准备学习Java的朋友有所帮助。