基本数据类型介绍

Java 中定义了 3 类 8 种基本数据类型

• 数值型：byte、short、int、long、float、double
• 字符型（文本型）：char
• 布尔型：boolean

数据类型分类如下：

其中：

• 引用数据类型：4 个字节，其代表对象的地址
• 字符型（char）：2 个字节
• 布尔型（boolean）：1 bit（1 位 ）
• 数值型：
  • 整数类型：
    1. byte：1 个字节
    2. short：2 个字节
    3. int：4 个字节
    4. long：8 个字节
  • 浮点类型：
    1. float：4 个字节
    2. double：8 个字节

整型变量/常量

整型用于没有小数部分的数值，其允许是负数。

一个字节表示范围是 2 的 8 次方（即 256 个数：-128 ~ 127）。
两个字节表示范围是 2 的 16 次方（-23768 ~ 32767），范围大约在正负 3 万之间。
三个字节表示范围是 2 的 32 次方，范围大约在正负 21 亿之间。

Java 语言的整型常量默认为 int 型，声明 long 型常量可以后加 ‘l’ 或 ‘L’

假如定义的数据类型变量值超出范围，会报错。

byte age = 300;  // 报错，因为 byte 的范围是 -128~127（2 的 8 次方）
byte age1 = 30;   // 正常
short salary = 300000000;  // 报错，short 数据类型的表数范围是 2 个字节(2 的 16 次方)
short salary1 = 30000;     // 正常
int pop = 20000000000;     // 报错（200亿），int 表数范围是 4 个字节，范围大约在正负21亿之间
int pop1 = 2000000000;     // 正常（20亿），
// 定义 long 长整型常量
long one = 74000000000;    // 报错，因为整型常量默认是 int 类型，所以此处超出范围了
long one1 = 74000000000L;   // 在数值后面加上一个 L / l 字母，就代表这是一个 long 类型常量
long one2 = 74000000000l;   // 最好是加 L，方便辨别

Java 语言整型常量的四种表现形式

1. 十进制整数，如：99，-500,0
2. 八进制整数，要求以 0 开头，如 015
3. 十六进制数，要求 0x 或 0X 开头，如：0x15
4. 二进制数，要求 0b 或 0B 开头，如：0b01110011

// 测试整型常量
int a = 15;
int b = 015;  // 这是八进制数
int c = 0x15;  // 这是十六进制
int d = 0b011101;  // 这是二进制
int e = 0B011101;  // 这是二进制
System.out.println(a);   // 结果为 15
System.out.println(b);   // 结果为 13
System.out.println(c);   // 结果为 21
System.out.println(d);   // 结果为 29
System.out.println(e);   // 结果为 29

浮点型变量/常量

带小数的数据在 Java 中称为浮点型。
浮点数据类型分两种：float、double
float 占 4 个字节，double 占 8 个字节。
浮点型常量的默认类型是 double。
浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用 BigDecimal 类

float 称为单精度类型，尾数可精确到 7 位有效数字，多数情况，float 类型的精度很难满足需求。
double 称为双精度类型，数值精度约是 float类型 的两倍。绝大部分应用程序都采用 double 类型。

Java 浮点类型常量的两种表现形式：

• 十进制数形式，如：3.14、314.0、0.314
• 科学计数法形式，如：314e2、314E2、314E-2

科学计数法示例：

double f = 314e2; // 314*10^2 -->> 31400.0
double f2 = 314e-2; // 314*10^(-2) -->> 3.14

flaot 类型赋值时需要添加后缀 F/f

// 浮点型若未声明，默认是 double。
// float 加 F/f 进行声明，才能放进 float 类型中。float 和 double 的字节数不同，所以报错
float a = 3.14;   // 报错，定义 float，需要加 F/f 进行声明
float a1 = 3.14F; // 正常
float a2 = 3.14f; // 正常

注意点

浮点类型float、double 的数据不适合在不容许舍入误差的金融计算领域，如果需要进行不产生舍入误差的精确数字计算，需要使用 BigDecimal 类。
float 类型后缀为 F/f，没有 F/f 则默认为 double 类型。
可在浮点数值后添加 D/d 后缀，以明确其为 double 类型。

float f = 3.14F;
double d1 = 3.14;
double d2 = 3.14D;

浮点数比较（错误示范）

浮点数是不精确的，不能用于数值比较

// 浮点数是不精确的，不能用于数值比较
// 此处结果为 false
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);   // 结果为 false。利用 == ，对两个变量进行数值比较

浮点数运算比较验证

// 浮点数运算比较验证，此处输出结果为 d1==d2 ,由此说明浮点数是不精确的。
float d1 = 423432143f;
float d2 = d1 + 1;   // 在原来的基础上加个 1
if(d1==d2){
  System.out.println("d1==d2"); // 输出结果为 d1==d2
}else{
  System.out.println("d1 != d2"); 
}

数值之间如何计算？

java.math 包中有两个类：BigInteger 和 BigDecimal
这两个类可以处理任意长度的数值。

代码示例：使用 BigDecimal 进行浮点数的比较

import java.math.BigDecimal;
public class testNumericalJ {
    public static void main(String[] args){
        // 使用精确浮点运算，推荐 BigDecimal
        BigDecimal bd = BigDecimal.valueOf(1.0);  // 定义了 bd 值为 1.0  ，即 bd = 1.0
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        // 两者对比，上方 subtract 词义是 减，进行了 5 次减 0.1 的操作。
        System.out.println(bd);  // 输出结果为 0.5
        System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); // 输出结果为 0.5000000000000001

        // 定义 bd2，bd3，做比较验证
        BigDecimal bd2 = BigDecimal.valueOf(0.1);    // 定义 bd2 初值为 0.1
        BigDecimal bd3 = BigDecimal.valueOf(1.0/10); // 定义 bd3 初值为 1.0/10
        // 比较 bd2 和 bd3
        System.out.println(bd2.equals(bd3));         // 输出结果为 true
    }
}

字符型变量/常量

字符型在内存中占两个字节，在 Java 中使用单引号来表示字符常量。
例如：单引号包裹的 'A' 表示一个字符，而双引号包裹的 "A" 表示含有一个字符的字符串
char 类型用来表示在 Unicode 编码表中的字符。
Unicode 编码被设计用来处理各种语言的文字，其占 2 个字节，可允许 65536 个字符。
多个字母，如 'abc'，这种就需要用 String 类型来进行声明，无法使用 char 进行声明。char 只适用于单个字符或数字
String 即字符序列。

可以用单引号包裹表示字符型，也可以用 Unicode 编码去表示字符型

示例：字符型举例

char a = 'T';
char b = '中';
char c = '\u0061';  // 表示字符 a

Unicode 具有从 0 到 65535 之间的编码，其通常从 ‘\u0000’ 到 ‘\uFFFF’ 之间的十六进制数来表示（前缀为 u 则说明是 Unicode）

转义字符 '\'

Java 语言中允许使用转义字符 '' 来将其后的字符转变为其他的含义
常见转义字符的含义和 Unicode 值如图：

代码示例：转义字符

// 转义字符
public class testPrimitiveDateType2 {
    public static void main(String[] args){
        // 转义字符
        // 遇到符号 + 时，a 和 b 会自动转化为数字
        System.out.println('a'+'b');  // 结果为 195
        // 通过在前方增加一个空字符串，让语句识别为字符串拼接，最终获得结果为 ab
        System.out.println(""+'a'+'b');  // 结果为 ab
        // 在 a 和 b 之间换行，使用 \n 换行符
        System.out.println(""+'a'+'\n'+'b');  // 一行输出 a，后一行输出 b
        // 在 a 和 b 之间增加一个 \t 制表符长度
        System.out.println(""+'a'+'\t'+'b');  // 输出结果为 a  b，中间有一段为制表符占位
        // 在 a 和 b 之间增加一个单引号 '
        System.out.println(""+'a'+'\''+'b');  // 输出结果为 a'b，使用 \ 来对单引号 ' 进行转义输出
    }
}

boolean 类型变量/常量

boolean 类型有两个常量值：true 、false
在内存中占一位（不是一个字节）
不可以使用 0 或 非0 的整数来代替 true 和 false，这点与 C 语言有所不同
boolean 类型用来判断逻辑条件，一般用于程序流程控制。

代码示例：boolean 类型

// 测试布尔类型，测试结果为 “这里是 flag 是 true 的打印”
boolean flag;
flag = true; // 或者 flag = false
if (flag){
    System.out.println("这里是 flag 是 true 的打印");  // 打印这个结果
}else{
    System.out.println("这里是 flag 是 false 的打印");
}

细节代码记录：第一时间我误判了

// 说出程序执行结果

boolean man = false;

if (man=true){
    System.out.println("男性");
}else{
    System.out.println("女性");
}

// 打印结果为男性，因为 if 判断语句中对 man 进行了重新赋值。值由 false 变为了 true

至此，基本数据类型结束