程序员scholar
  • Java
  • JavaSE - 基础篇
scholar
2024-03-17
目录

Java数据类型

# 前言

Java以前自学过一些，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。

# 1. Java数据类型概述

Java的数据类型分为两大类：

  • 基本数据类型
    • 整数类型：包括byte、short、int和long四种类型，用于表示整数。
    • 浮点类型：包括float和double两种类型，用于表示带小数点的数值。
    • 布尔类型：boolean类型，只有true和false两个值，用于表示逻辑值。
    • 字符类型：char类型，用于表示单个字符，它是基于Unicode编码的。
  • 引用数据类型
    • 类、接口、数组、枚举等。（或者你也可以这样记：除了8种基本数据类型之外，其他都是引用数据类型，包括String。）

image-20210628142322228

现阶段重点研究基本数据类型，以后再说引用数据类型。

下面详细介绍一下每种类型的特点和使用方法：

  1. 整数类型：
  • byte类型：占用1个字节，范围是-128到127，常用于存储小整数。 (byte类型的1：00000001)
  • short类型：占用2个字节，范围是-32768到32767，常用于存储中等大小的整数。 (short类型的1：00000000 00000001)
  • int类型：占用4个字节，范围是-2147483648到2147483647，是Java中最常用的整数类型。
  • long类型：占用8个字节，范围是-9223372036854775808到9223372036854775807，用于存储极大或极小的整数。

为什么设计出这么多整数？目的是为了选择合适的数据类型，节省空间，但实际开发中不必斤斤计较，大部分采用int。另外，如果数据过大，超过了long，可以使用BigInteger，它就不是基本数据类型了，属于引用数据类型。后面再说。

  1. 浮点类型：
  • float类型：占用4个字节，范围是1.4E-45到3.4028235E38，精度为7位小数，常用于科学计算和工程计算。
  • double类型：占用8个字节，范围是4.9E-324到1.7976931348623157E308，精度为15位小数，是Java中最常用的浮点类型。 （如果超出了double，可以使用BigDecimal，同样它也是一种引用数据类型。）
  1. 布尔类型：
  • boolean类型：只有两个值，true和false，用于表示逻辑值，例如判断语句、循环语句等。
  1. 字符类型：
  • char类型：占用2个字节，用于表示单个字符，例如'A'、'B'、'C'等，也可以表示Unicode编码中的任意字符。

这是一个直观的列表：

数据类型 占用字节数 取值范围 具体取值范围 默认值
byte 1 -2^7 ~ 2^7-1 -128 ~ 127 0
short 2 -2^15 ~ 2^15-1 -32768 ~ 32767 0
int 4 -2^31 ~ 2^31-1 -2147483648 ~ 2147483647 0
long 8 -2^63 ~ 2^63-1 -9223372036854775808 ~ 9223372036854775807 0L
float 4 1.4E-45 ~ 3.4028235E38 1.4E-45 ~ 3.4028235E38 0.0f
double 8 4.9E-324 ~ 1.7976931348623157E308 4.9E-324 ~ 1.7976931348623157E308 0.0d
boolean 1 true / false true / false false
char 2 0 ~ 2^16-1 0 ~ 65535 '\u0000'

关于默认值：Java语言中变量必须先声明，再赋值，才能使用。对于局部变量来说必须手动赋值，而对于成员变量来说，如果没有手动赋值，系统会自动赋默认值。例如：

public class DefaultValue {
    // 成员变量有系统默认值
    static int i;
    public static void main(String[] args){
        System.out.println(i); // 0
        // 成员变量没有系统默认值
        int k;
        System.out.println(k); // 编译报错
    }
}
1
2
3
4
5
6
7
8
9
10

注意：对于引用数据类型来说，默认值null，例如：

public class DefaultValue {
    static String name;
    public static void main(String[] args){
        // String是引用数据类型。
        System.out.println(name); // null
    }
}
1
2
3
4
5
6
7

# 2. 整数型详解

# 整数型字面量的四种表示形式

Java中整数型字面量有以下四种表示形式：

  1. 十进制表示法：以数字0-9组成的常数，默认为十进制表示法。

    例如：int a = 10;

  2. 二进制表示法：以0b或0B开头的常数，由0和1组合而成。

    例如：int b = 0b101;

  3. 八进制表示法：以0开头的常数，由数字0-7组成。

    例如：int c = 012;

  4. 十六进制表示法：以0x或0X开头的常数，由0-9和A-F（大小写均可）组成。

    例如：int d = 0x1F;

# 整数型字面量默认当做int处理

Java中整数型字面量默认被当做int类型来处理，如果要表示long类型的整数，需要在字面量后面加上'L'或'l'标记。例如，下面是表示int和long类型整数的字面量的示例：

int x = 10; // 10是一个int类型的字面量
long y = 10L; // 10L是一个long类型的字面量
1
2

需要注意的是，大小写字母'L'和'l'的使用没有区别，但是容易被误解为数字1，因此建议使用大写字母。 请看以下代码有什么问题吗？

long z = 2147483648;
1

编译报错，原因是2147483648被当做int类型处理，而该数字本身已经超出了int最大值，如何修改？

long z = 2147483648L;
1

# 自动类型转换

自动转换：

  • 将取值范围小的类型自动提升为取值范围大的类型 。

基本数据类型的转换规则如图所示：

  • 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
  • byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
  • boolean类型不能与其它数据类型运算。
  • 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

未命名文件.jpg

在Java中，对于基本数据类型来说，小容量是可以直接赋值给大容量的，这被称为自动类型转换。对于数字类型来说大小关系为：byte < short < int < long < float < double。

当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过
1
2
3
4
5
6
7

（2）当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double
1
2
3
4
5

（3）当byte,short,char数据类型进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113
1
2
3
4
5
6
7

需要注意的是，自动类型转换只适用于基本数据类型之间的转换。

# 强制类型转换

强制类型转换：Java中大容量是无法直接转换成小容量的。因为这种操作可能会导致精度损失，所以这种行为交给了程序员来决定，当然这种后果自然是程序员自己去承担。因此在代码中需要程序员自己亲手加上强制类型转换符，程序才能编译通过。 以下程序编译器就会报错：

int num = 10L;
1

解决方案两个：要么把L去掉，要么使用强制类型转换符，例如：

int num = (int)10L;
1

这样编译器就能编译通过了。

  • 那强制类型转换时，底层二进制是如何变化的？原则：砍掉左侧多余的二进制。例如以上程序的二进制变化是这样的：

  • long类型的10对应的二进制：00000000 00000000 00000000 00000000 00000000 00000000 00000000 00001010

  • 强制转换为int类型的10是这样的：00000000 00000000 00000000 00001010

因此，强制类型转换时，精度可能会损失，也可能不会损失，这要看具体的数据是否真正的超出了强转后的类型的取值范围。如下图：水可能溢出，也可能不会溢出，这要看真实存放的水有多少！！！

未命名文件 (1).jpg

如果你理解了强制类型转换，那么下面这个程序的执行结果可以推算出来吗？

byte b = (byte)150;
1
  • int类型的150的补码（150是正数：原码反码补码一样）：00000000 00000000 00000000 10010110
  • 强转砍掉前三个多出的字节，结果是：10010110（这个是最终存储在计算机中的，注意：存储在计算机中的是补码）
  • 将以上补码10010110推算出原码：11101010（结果是：-106）

因此int类型的150强转为byte类型之后，结果是-106

# 当整数字面量没有超出byte的范围

在Java中有这样一个规定，当整数型字面量没有超出byte的范围：可以直接赋值给byte类型的变量。

byte b = 127; // 这是允许的
1

很显然，这是一种编译优化。同时也是为了方便程序员写代码。 如果超出了范围，例如：

byte b = 128; // 编译报错
1

这样就会报错，需要做强制类型转换，例如：

byte b = (byte)128;
1

它的执行结果你知道吗？可以尝试推算一下，最终结果是：-128 在整数类型中，除了byte有这个待遇之外，short同样也是支持的。也就是说：如果整数型字面量没有超出short取值范围时，也是支持直接赋值的。

# 两个int类型做运算

两个int类型的数据做运算，最终的结果还是int类型：

int a = 10;
int b = 3;
int c = a / b; 
System.out.println(c); // 3
1
2
3
4

# 多种数据类型混合运算

在Java中，多种数据类型混合运算时，各自先转换成容量最大的类型，再做运算。

byte a = 100;
int b = 200;
long c = 300L;
long d = a + b + c;
1
2
3
4

你可以测试一下，如果d变量是int类型则编译器会报错。

# 编译器的小心思

以下程序编译通过：

byte x = 10 / 3;
1

为什么编译通过？这种情况下都是字面量的时候，编译器可以在编译阶段得出结果是3，而3没有超出byte取值范围。可以直接赋值。 以下程序编译报错：

int a = 10;
int b = 3;
byte x = a / b;
1
2
3

为什么编译失败？这种a和b都是变量的情况下，编译器是无法在编译阶段得出结果的，编译器只能检测到结果是int类型。int类型不能直接赋值给byte类型变量。 怎么解决？要么把x变量声明为int类型，要么强制类型转换，例如：

int a = 10;
int b = 3;
byte x = (byte)(a / b);
1
2
3

这里需要注意的是：注意小括号的添加，如果不添加小括号，例如：

int a = 10;
int b = 3;
byte x = (byte)a / b;
1
2
3

这样还是编译报错，因为只是将a强转为byte了，b还是int。byte和int混合运算，结果还是int类型。

# 3. 浮点型详解

浮点型类型包括：

  • 单精度（float）：4字节（32位）
  • 双精度（double）：8字节（64位），精度较高，实际开发中double用的多。

# 浮点型字面量默认被当做double

Java中，浮点型字面量默认被当做double类型，如果要当做float类型，需要在数字后面添加 F 或 f。

float f = 3.0; // 编译报错
1

报错原因是：3.0默认被当做double类型，大容量无法直接赋值给小容量。如何修改：

float f = 3.0F;
1

另外，可以通过以下程序的输出结果看到，double精度高于float：

double d = 1.5656856894;
System.out.println(d);

float f = 1.5656856894F;
System.out.println(f);
1
2
3
4
5

# 浮点型数据两种表示形式

第一种形式：十进制

double x = 1.23;
double y = 0.23;
double z = .23;
1
2
3

第二种形式：科学计数法

double x = 0.123E2; // 0.123 * 10的平方
double y = 123.34E-2; // 123.34 / 10的平方
1
2

# 浮点型数据存储原理

以单精度float为例： image.png

  • 符号位：0表示整数。1表示负数。

  • 指数位：比如小数0.123E30，其中30就是指数。表示0.123 * 10的30次幂。

    所以也有把指数位叫做偏移量的。最大偏移量127。

  • 尾数位：浮点数的小数部分的有效数字。例如：0.00123，那么尾数位存储123对应的二进制。

从浮点型数据存储原理上可以看到，二进制中的指数位决定了数字呈指数级增大。因此float虽然是4个字节，但却可以表示比long更大的数值。因此float容量比long的容量大。

# 使用浮点数的注意事项

计算机的二进制位有限，现实世界中有无限循环的数字，例如3.333333333333333333..........，因此计算机这种有限资源去存储无限数据是不可能的，所以浮点型数据在底层真实存储的时候都是采用近似值的方式存储的。尾数位越多精度越高。

  • 实际上包括0.1这样简单的数字，浮点型数据也是无法精确存储的。(想了解更多，请查看相关文献)

  • 这样就会有一个问题，请看以下程序：

double x = 6.9;
double y = 3.0;
double z = x / y;
System.out.println(z);
1
2
3
4

它的执行结果是：2.3000000000000003，并不是2.3

因此一旦有浮点型数据参与运算得出的结果，一定不要使用“==”与其它数字进行“相等比较”。

例如，以下代码就存在问题：

double x = 6.9;
double y = 3.0;
double z = x / y;
if(z == 2.3){
    System.out.println("相等");
}
1
2
3
4
5
6

执行发现并没有输出：相等。

原因是判断条件有问题。

如果确实需要进行比较，可以将代码修改为如下：

double x = 6.9;
double y = 3.0;
double z = x / y;
if(z - 2.3 < 0.000001){
    System.out.println("相等");
}
1
2
3
4
5
6

也就是说，如果这两个数字之间的差小于0.000001，我就认为是相等的。

因此：如果有浮点型数据参与运算得出了结果，不要拿着这个结果和另一个数据进行“==”相等比较。

# 4. 字符型详解

char：字符型，占用2个字节。取值范围0~65535。和short（-32768~32767）所表示的个数相同。但char可以表示更大的整数。

字符型字面量采用单引号括起来，例如：'a'、'A'、'0'、'国' 等。

字符型字面量只能是单个字符，不能是多个字符。

Java中char类型可以存储一个汉字。

char c1 = 'A';
char c2 = 'a';
char c3 = '0';
char c4 = '国';
char c5 = '¥';

// 编译报错
//char c6 = 'ab';
1
2
3
4
5
6
7
8

再看下面程序：

char x = '';
1

编译报错。由于单引号中没有任何字符，因此无法给 c 赋值，所以会导致编译报错，提示无效的字符字面量。

如果要赋给 c 一个空的字符，可以使用转义字符 '\u0000' 来表示。如下所示：

char c = '\u0000'; // 赋给 c 一个空字符
1

注意：空字符与空格字符完全是两码事。

# 转义字符

Java 中的转义字符是一些在字符串中具有特殊含义的字符序列，它们以反斜线（\）开始。以下是 Java 中的一些常用转义字符：

  • \t: 表示制表符，相当于按下 Tab 键
  • \n: 表示换行符
  • \r: 表示回车符
  • ": 表示双引号（"）
  • ': 表示单引号（'）
  • \: 表示反斜线（\）本身

这些转义序列可以用于不同的 Java 数据类型，如字符串、字符等。在 Java 编程中，转义字符可以帮助我们在字符串中表示一些特殊的字符，例如制表符、换行符、引号等。例如，下面的代码演示了如何使用转义字符来创建包含制表符和换行符的字符串：

String str = "Hello\tworld\nHow are you?";
System.out.println(str);
1
2

这个例子中，\t 和 \n 分别表示字符串中的制表符和换行符。输出结果是：

Hello   world
How are you?
1
2

# 字符编码的理解

字符编码（Character encoding）是计算机系统中使用的一种将字符集中的字符转换为二进制数据的方式，从而方便计算机的存储和传输。在计算机内部，所有的信息都是以二进制形式存储和处理的，因此字符编码是将字符和二进制数据之间的转换方式。每一个字符在计算机中都有其对应的二进制代码。不同的字符编码可以采用不同的编码方式将字符映射到二进制代码，最终这些二进制代码被存储在计算机内部。

在早期计算机系统中，字符编码主要采用的是 ASCII 编码，采用1个字节编码。最多可以表示256个字符。（实际上ASCII码表只用了128个。）

以下是ASCII码表：

十进制 字符 十进制 字符 十进制 字符 十进制 字符
0 NUL 32 SPACE 64 @ 96 `
1 SOH 33 ! 65 A 97 a
2 STX 34 " 66 B 98 b
3 ETX 35 # 67 C 99 c
4 EOT 36 $ 68 D 100 d
5 ENQ 37 % 69 E 101 e
6 ACK 38 & 70 F 102 f
7 BEL 39 ' 71 G 103 g
8 BS 40 ( 72 H 104 h
9 HT 41 ) 73 I 105 i
10 LF 42 * 74 J 106 j
11 VT 43 + 75 K 107 k
12 FF 44 , 76 L 108 l
13 CR 45 - 77 M 109 m
14 SO 46 . 78 N 110 n
15 SI 47 / 79 O 111 o
16 DLE 48 0 80 P 112 p
17 DC1 49 1 81 Q 113 q
18 DC2 50 2 82 R 114 r
19 DC3 51 3 83 S 115 s
20 DC4 52 4 84 T 116 t
21 NAK 53 5 85 U 117 u
22 SYN 54 6 86 V 118 v
23 ETB 55 7 87 W 119 w
24 CAN 56 8 88 X 120 x
25 EM 57 9 89 Y 121 y
26 SUB 58 : 90 Z 122 z
27 ESC 59 ; 91 [ 123 {
28 FS 60 < 92 |124
29 GS 61 = 93 ] 125 }
30 RS 62 > 94 ^ 126 ~
31 US 63 ? 95 _ 127 DEL

作为程序员，我们应当记住以下几个常用字符的ASCII码：

  • a 对应ASCII码 97（b是98，以此类推）
  • A 对应ASCII码 65（B是66，以此类推）
  • 0 对应ASCII码 48（1是49，以此类推） 什么是解码？什么是编码？乱码是如何产生的？

在计算机系统中，解码（Decoding）和编码（Encoding）是两个常用的概念，分别表示将二进制数据转换为字符和将字符转换为二进制数据。 编码是将字符转换为二进制数据的过程。解码是将二进制数据转换为字符的过程。例如：

  • 'a' ---------按照ASCII码表编码-----------> 01100001
  • 01100001 --------按照ASCII码表解码------------> 'a'

乱码是指在字符编码和解码的过程中，由于编码和解码所采用的字符集不一致，或者编码和解码所采用的字符集不支持某些字符，导致最终显示的字符与原始字符不一致。为了避免乱码的问题，我们需要统一使用一个字符集，并且在进行字符编码和解码时要保持一致。

# 常见的字符编码

常见的字符编码方式如下：

  1. ASCII 编码（American Standard Code for Information Interchange：美国信息交换标准编码）：采用1个字节编码，包括字母、数字、符号和控制字符等。
  2. Latin-1编码（ISO 8859-1），采用1个字节编码。该编码方式是为了表示欧洲语言（如荷兰语、西班牙语、法语、德语等）中的字符而设计的，共支持 256 个字符。
  3. ANSI 编码（American National Standards Institute：美国国家标准协会）：采用1个字节编码，支持英文、拉丁文等字符。
  4. Unicode 编码：可表示所有语言的字符。采用了十六进制表示，占用 2 个字节或 4 个字节，最多可表示超过一百万个字符。 （使用这种方式是有点浪费空间的，例如英文字符'a'其实采用一个字节存储就够了。）
  5. UTF-8 编码（Unicode Transformation Format，8-bit）：基于 Unicode 编码的可变长度字符编码，能够支持多语言和国际化的需求，使用 1~4 个字节来表示一个字符，是目前 Web 开发中最常用的字符编码方式。 （一个英文字母1个字节，一个汉字3个字节。）
  6. UTF-16 编码：基于 Unicode 编码的可变长度字符编码，使用 2 或 4 个字节来表示一个字符，应用于很多较早的系统和编程语言中。 （一个英文字母2个字节。一个汉字4个字节。）
  7. UTF-32编码：基于Unicode编码的固定长度字符编码，其特点是每个字符占用4个字节。
  8. GB2312 编码（小）：是中国国家标准的简体中文字符集，使用 2 个字节来表示一个汉字，是 GBK 编码的前身。
  9. GBK 编码（Guo Biao Ku）（中）：是针对中文设计的一个汉字编码方式，使用 2 个字节来表示一个汉字，能够表示中国内地的所有汉字。
  10. GB18030编码（大）：是中国国家标准GB 18030-2005《信息技术 中文编码字符集》中规定的字符集编码方案，用于取代GB2312和GBK编码。
  11. Big5 编码（大五码）：是台湾地区的繁体中文字符集，使用 2 个字节来表示一个汉字，适用于使用繁体中文的应用场景。

每种编码方式都有其特点和适用场景。在进行软件开发、网站开发和数据存储时，需要根据实际情况选择适合的编码方式。

注意：Java语言中的字符char和字符串String，都是采用Unicode编码。

# Unicode码表

Unicode码表示的一部分：

十六进制码 字符 名称 符号
U+0020 空格 (space)
U+0021 ! 感叹号 (exclamation mark)
U+0022 " 双引号 (quotation mark)
U+0023 # 井号 (number sign)
U+0024 $ 美元 (dollar sign)
U+0025 % 百分号 (percent sign)
U+0026 & 和号 (ampersand)
U+0027 ' 单引号 (apostrophe)
U+0028 ( 左括号 (left parenthesis)
U+0029 ) 右括号 (right parenthesis)
U+002A * 星号 (asterisk)
U+002B + 加号 (plus sign)
U+002C , 逗号 (comma)
U+002D - 减号 (hyphen,-minus sign)
U+002E . 句点 (full stop,period)
U+002F / 斜杠 (slash,forward slash)
U+0030 0 零 (digit zero)
U+0031 1 一 (digit one)
U+0032 2 二 (digit two)
U+0033 3 三 (digit three)
U+0034 4 四 (digit four)
U+0035 5 五 (digit five)
U+0036 6 六 (digit six)
U+0037 7 七 (digit seven)
U+0038 8 八 (digit eight)
U+0039 9 九 (digit nine)
U+003A : 冒号 (colon)
U+003B ; 分号 (semicolon)
U+003C < 小于号 (less than sign)
U+003D = 等于号 (equals sign)
U+003E > 大于号 (greater than sign)
U+003F ? 问号 (question mark)
U+0040 @ 艾特符号 (commercial at)
U+0041 A 拉丁大写字母A (Latin capital letter A)
U+0042 B 拉丁大写字母B (Latin capital letter B)
U+0043 C 拉丁大写字母C (Latin capital letter C)
U+0044 D 拉丁大写字母D (Latin capital letter D)
U+0045 E 拉丁大写字母E (Latin capital letter E)
U+0046 F 拉丁大写字母F (Latin capital letter F)
U+0047 G 拉丁大写字母G (Latin capital letter G)

在Java程序中也可以使用Unicode码来指定char变量的值：

char c = '\u0041';
1

输出结果是：A

网络上也有很多在线转码工具，例如：http://www.jsons.cn/unicode/ (opens new window)

# char参与的运算

Java中允许将一个整数赋值给char类型变量，但这个整数会被当做ASCII码值来处理，例如：

char c = 97;
System.out.println(c);
1
2

会将97当做ASCII码值，该码值转换char类型是字符'a'，所以输出结果是：a 但需要特别注意的是，这个码值有要求，不能超出char的取值范围。如果是这样的，编译会报错：

// 编译报错
char c = 65536;
1
2

所以结合之间的byte和short，可以有这样一个结论（记住）：只要没有超出byte short char的取值范围，是可以直接赋值给byte short char类型变量的。例如：

byte b = 1;
short s = 1;
char c = 1;
1
2
3

再看以下程序输出结果：

System.out.println('a' + 1);
1

输出结果是：98。这是因为1是int类型，所以'a'会被转换为int类型。 再看以下程序输出结果：

char c = 'a' + 1;
System.out.println(c);
1
2

输出结果是：b。这是因为c的类型是char类型。 再看以下程序输出结果：

byte b = 1;
short s = 1;
char c = 1;
short num = b + s + c;
1
2
3
4

编译报错：第4行的等号右边是int类型，int类型无法赋值给short类型的变量。 这里有一个结论需要记住：byte short char混合运算时，各自会先转换成int再做运算。

# 5. 布尔型详解

# 关于布尔型的值

Java中的布尔型，关键字：boolean 只有两个值：true、false。没有1和0这一说。 true表示真，false表示假。

# 布尔值通常使用在哪

Java中的布尔值（boolean）通常用于表示一些逻辑上的真假值，并在程序中进行逻辑控制。以下是布尔值在Java中常用的场景：

  1. 条件语句，if和while等语句中需要进行条件判断时，通常使用布尔类型的变量作为条件表达式，根据条件的真假情况执行不同的代码逻辑。
  2. 逻辑运算，布尔值是逻辑运算的基础，Java中的逻辑运算符有：与（&&）、或（||）、非（!）等，常用于对布尔值的运算和操作。
  3. 方法返回值，可以将布尔值作为方法的返回值，表示某种条件是否满足。
  4. 开关标记，布尔变量在程序中常用于开关标记的判断和设置，例如，当某个功能开启或关闭时，我们可以用布尔类型的变量来表示。

综上所述，Java中的布尔值在程序中有很多用途，可以在很多场景下提供非常便利的逻辑控制和判断能力。

下面是一个使用布尔值的简单案例：

boolean gender = true;
if(gender){
    System.out.println("男");
}else{
    System.out.println("女");
}
1
2
3
4
5
6

# 6. 基本数据类型转换规则总结

  1. 八种基本数据类型，除布尔型之外，其它类型都可以互相转换。
  2. 小容量转换为大容量，叫做自动类型转换，容量从小到大的排序为：
    1. byte < short(char) < int < long < float < double
    2. 注意char比short可以表示更大的整数
  3. 大容量转换为小容量，叫做强制类型转换，需要加强制类型转换符才能编译通过，运行时可能损失精度，也可能不会损失。
  4. 整数字面量如果没有超出byte short char的取值范围，可以直接赋值给byte short char类型的变量。
  5. byte short char混合运算，各自先转换为int再做运算。
  6. 多种类型混合运算，各自先转换成容量最大的类型，再做运算。

以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是scholar，一个在互联网行业的小白，立志成为更好的自己。

如果你想了解更多关于scholar (opens new window) (opens new window)，可以关注公众号-书生带你学编程，后面文章会首先同步至公众号。

公众号封面

编辑此页 (opens new window)
上次更新: 2024/12/28, 18:32:08
Java基础语法
Java常量和变量

← Java常量和变量→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar