Java基础教程之程序概念 · 上

本节学习目标
1️⃣ Java中的注释
2️⃣ 标识符
3️⃣ 关键字
4️⃣ 数据类型
- 4.1 整型
- - 🔍 什么是变量？什么是常量？
  - 🔍关于数据类型转换的规则？
- 4.2 浮点数
- - 🔍关于Java的计算的缺陷
- 4.3 字符型
- - 🔍一些常用编码范围
- 4.4 布尔型
- 4.5 字符串型
🌾 总结

在这里插入图片描述

本节学习目标

掌握Java中标识符的定义；
掌握Java中数据类型的划分以及基本数据类型的使用原则；
掌握Java运算符的使用；

1️⃣ Java中的注释

在编写程序时，为了提高程序的可维护性，我们可以在代码中添加注释。注释是一种说明性的文字，不会被编译器编译执行。

Java提供了三种注释形式：

//：单行注释（以双斜线 // 开始）；
/*...*/：多行注释（以 /* 开始，以 / 结束）；
/**...*/：文档注释（以 /** 开始，以 */ 结束）。

单行注释
单行注释，就是在注释内容前面加双斜线（//），Java编译器在进行程序编译时会忽略掉这部分信息。例如：

//案例1：单行注释
public class TestDemo{
	public static void main(String[] args){
		//此处为注释，编译代码时不会被编译
		System.out.println("Hello xiaoshan.");
	}
}

多行注释
多行注释，就是在注释内容前面以单斜线加一个星号（/*）开头，并在注释内容末尾以一个星号加单斜线（*/）结束。当注释内容超过一行时一般使用这种方法。例如：
```
//案例2：多行注释
public class TestDemo{
	public static void main(String[] args){
		/*
		 * 此处为多行注释，编译代码时不编译
		 */
		System.out.println("Hello xiaoshan.");
	}
}
```
文档注释
文档注释，是以单斜线加两个星号（/**）开头，并以一个星号加单斜线（*/）结束。用这种方法注释的内容会被解释成程序的正式文档，并能包含进如 javadoc工具生成的文档里，用以说明该程序的层次结构及其方法。
```
//案例3：文档注释
/**
*此处为文档注释
*@author xiaoshan
*@Date 2023/07/05
*/
public class TestDemo{
	public static void main(String[] args){
		System.out.println("Hello xiaoshan.");
	}
}
```
在文档注释中提供了许多类似于“@author”、“@Date”的标记，例如：参数类型、返回值、方法说明等。

需要特别注意的是，在软件开发中文档注释是非常重要的。作为开发人员，技术文档是必不可少的工具之一，而且每个操作和功能在文档中都有详细的解释。因此，本文也建议读者在编写代码时养成良好的编程习惯，即添加适当的代码注释。这将帮助提高代码的可读性和可维护性，并为团队合作和未来的项目更新提供更好的支持。

2️⃣ 标识符

在前面的文章《【Java基础教程】（二）入门介绍篇 · 下》中，给出了一个程序的基本结构：

public class 类名称{ }

这里类名称的定义就属于一个标识符的定义范畴，而除了类名称之外，Java中属性（也叫字段）名称、方法名称等也都属于标识符的定义范畴，但是在Java中每一个标识符都有自己的严格定义要求。

标识符的定义要求是：标识符可由字母、数字、_、$ 组成，其中不能以数字开头，不能是Java中的关键字（也称保留字）。对于标识符的定义，除了应满足以上的规则要求，还应该注意以下问题：

命名尽量有意义，避免使用“a” “b” “c”这样不具备意义的标识符。例如：student、name此类属于见名知意的标识符；
Java中标识符是区分大小写的，例如：xiaoshan、XIAOSHAN、XiaoShan表示3个不同的标识符；
对于“$”符号有特殊意义，避免去使用它（后文讲解）；
特别地，对于类名的定义，每个单词首字母应该大写，例如：DemoClass；
特别地，对于属性名、方法名的定义，应满足驼峰命名规则，即首个单词的首字母小写，其他单词首字母大写，例如：getName；
特别地，对于常量的定义，每个字母应该大写，例如：AGE。

为了帮助大家更好的理解标识符的定义，请看下面两组合法与非法标识符的对比：

下面是合法的标识符
name、age、address
下面是非法的标识符
class（关键字）、public（关键字）、68.6（数字开头和包含非法字符 .）、xiao shan（包含非法字符空格）

有趣的是，从JDK1.7开始标识符增加了中文的支持，即：标识符可以使用中文定义。不过虽然Java给予了中文很好的支持，但在实际开发中还是建议按照习惯性的开发标准通过英文编写程序。

3️⃣ 关键字

关键字是指具备有特殊含义的单词，例如：public、class、static 这些都属于关键字，关键字全部用小写字母的形式表示，在Java中可以使用的关键字罗列如下：
在这里插入图片描述

有一点需要注意的是，读者朋友们不需要死记硬背Java中的关键字。对于初学者来说，可能感到要记住所有关键字是一件繁琐的事情。但其实随着对知识的熟悉度提升，这些内容都会逐渐被记住，所以无需强行记忆。而回顾之前学过的内容时，会发现已经见过类似public、class、void、static等关键字。所以，最好的掌握方法是多学多练，通过实际编程来深入理解和掌握一门编程语言。

下面对所有给出的关键字作以下几点说明：

Java有两个未使用到的关键字：goto（在C语言中表示无条件跳转）、const（在C语言中表示常量）；
assert关键字和enum关键字分别是 JDK1.4之后和 JDK1.5之后增加的；
Java有3个特殊含义的标记（严格讲不算是关键字）：true、false、null。

4️⃣ 数据类型

在程序设计中，数据的处理是最本质的，因此对于数据的存储必须有严格的限制。这些限制体现在数据类型的划分上，不同的数据类型可以保存不同类型的数据内容。

在Java中，数据类型可分为基本数据类型和引用数据类型。基本数据类型包括byte、short、int、long、float、double、char、boolean等最基本的类型，引用数据类型（类似于C/C++中的指针）在操作时需要进行内存空间的分配（如图1示）。基本数据类型不涉及内存分配问题，而引用数据类型需要开发人员为其分配内存空间，并进行关联匹配。

图1 Java中的数据类型

本节主要讲解各个基本数据类型。基本数据类型不牵扯内存的开辟问题，引用类型牵扯内存的开辟，并且引用类型作为整个Java入门的第一大难点，所以将在后面面向对象部分的文章中进行深入分析。同时需要注意的是，对于数据类型的划分以及数据类型的名称都要熟记。

Java的基本数据类型主要以数值的方式进行定义，这些基本数据类型的保存数据范围如下表所示：

基本数据类型	说明	占用空间	取值范围
byte	字节型	1 byte	-128~127
short	短整型	2 byte	-32768~32767
int	整型	4 byte	-2^31~ 2^32-1
long	长整型	8 byte	-2^63~ 2^64-1
float	单精度浮点型	4 byte	-2^31~ 2^32-1
double	双精度浮点型	8 byte	-2^63 ~ 2^64-1
char	字符型	2 byte	一个Unicode字符
boolean	布尔型	1 byte	true或false

一般来说，我们使用int来表示整数值（比如人的年龄），而使用double来表示小数值（如成绩或工资）。

如果需要表示日期时间或文件大小（以字节为单位），可能会选择long类型。而如果涉及到内容传递（IO操作、网络编程）或编码转换（如JSP开发中使用UTF8编码），我们通常会选择byte类型。

在当涉及到逻辑控制时，boolean类型非常合适（它只有两个值：true和false）。另外，当处理中文时，使用char类型可以避免乱码问题。

而由于计算机硬件价格（如CPU、内存、磁盘）逐渐降低，对数据类型大小的严格限制也不再像初始阶段编程那样必要。因此，像short和float这样的数据类型在大多数项目中是很少出现的。

下面主要对各种常用的基本数据类型的使用进行说明。

4.1 整型

任何一个数字常量（如30、100），在Java中都属于int数据类型。也就是说在Java中所有设置的整数内容默认情况下都是int型数据。下面案例演示了如何定义int型变量。

//案例4：定义`int`型变量
public class TestDemo{
	public static void main(String args[]){
		//为变量设置内容使用如下格式：数据类型 变量名称 = 常量;
		int num = 10;	//10是常量，常量的默认类型是int
		int result = num*2;	//利用num变量的内容乘以2，并且将其赋值给result
		System.out.println(result);	//输出result变量
	}
}

程序执行结果：

上边案例程序首先定义了一个num的变量，并在定义变量时为其赋值为10，随后利用num变量的内容乘以一个整型常量2，并且将其计算结果（20）赋值给result变量，最后进行了result变量的输出，所以最终的输出结果就是“20”。本程序实际上只实现了一个简单的乘法算术运算，Java中可以使用“+”（加法）、“-”（减法）、“*”（乘法）、“/”（除法）实现基本的四则运算操作。

🔍 什么是变量？什么是常量？

实际上变量与常量最大的区别只有一个：常量的内容是固定的，而变量的内容是可以改变的。

变量是利用声明的方式，将内存中某个内存块保留下来以供程序使用。可以声明的数据类型为整型、字符型、浮点型或是其他数据类型，作为变量的保存使用。变量在程序语言中扮演最基本的角色。变量可以用来存放数据，而使用变量之前必须先声明它的数据类型。常量顾名思义就是一个固定的数值，是不可改变的，例如：数字1、2就是一个整型的常量。

案例：观察变量与常量的区别。

//案例5：变量与常量的区别
public class TestDemo{
	public static void main(String args[]){
		//所有的变量名称在同一块代码中只允许声明一次
		int num = 10;			//10是常量，常量的默认类型是int
		num=num*2;		//取出num变量的内容乘以2，并且将其设置给num变量
		System.out.println(num);
	}
}

程序执行结果：

上边案例程序首先定义了一个num的变量，并且为其赋值为10，然后利用num变量的内容乘以数字2，最后将计算结果又赋值给变量num（此时num的内容已经发生了改变，因为其内容可变所以称其为变量），最终num变量的内容就是20。

在上文中已经为读者列出了每种基础数据类型的取值范围，如果已经超过了其保存的最大范围会如何呢？下面通过一个具体的程序来观察此类问题。

//案例6：数据溢出
public class TestDemo{
	public static void main(String args[]){
		int max=Integer.MAX_VALUE;	//取出最大值
		int min = Integer.MINVALUE;	//取出最小值
		System.out.println(max);
		System.out.println(min);
		//int变量 ± int型常量 = int型数据
		System.out.println(max+1);		//最大值加1：2147483648
		System.out.println(min-1);		//最小值减1：2147483647
		System.out.println(min-2);		//最小值减2：2147483646
	}
}

程序执行结果：

2147483647
-2147483648
-2147483648
2147483647
2147483646

本程序首先利用Integer.MAXVALUE和 Integer.MINVALUE 取得int数据类型的最大值与最小值，然后分别进行超过数据保存范围的数学计算。由于max或min变量都属于int型变量，而当int型变量与int型常量进行计算后其结果依然是int型。

但是此时由于计算超过了其保存的范围，就会出现一个循环的操作，最大值如果继续增加就变为最小值，随后一直向其次的最小值进行循环，反之最小值减1就变为最大值，此种现象称为数据的溢出（如图2所示）。

图2 int类型的数据溢出

学习过汇编语言的读者应该知道，在计算机中二进制（01）是基本的组成单元，而int型数据一共占32位（bit）长度，也就是说第一位是符号位，其余的31位都是数据位。

当数据已经是该数据类型保存的最大值时，如果继续进行“+1”的操作就会造成符号位的变更，最终就会形成这种数据溢出的问题。但也不用过于担心开发中出现数据溢出问题，只要控制得当并且合乎实际逻辑辑（例如：定义一个人年龄的时候是绝对不应该出现数据溢出问题，如果真出现了数据溢出，那么这样的数据已经是违背现实逻辑的了），自然也很少会出现此类情况。

而如果要想解决溢出问题，就只能通过扩大数据范围的方式来实现。比int范围更大的是long数据类型，将int型的变量或常量变为long数据类型有如下两种形式。

int型常量转换为long型常量，使用“数字L”或者“数字l（小写的字母L）”完成；
int型变量转换为long型变量，使用“（long）变量名称”。实际上可以用此类方式实现各种数据类型的转换，例如：如果将int型变量变为double型变量，可以使用“（double）变量名称”，即通用转换格式“（目标数据类型）变量”。

以下是一个案例来演示如何扩大数据类型：

//案例7：扩大数据类型
public class TestDemo{
	public static void main(String args[]){
		int max = Integer.MAX_VALUE;	//取出最大值
		int min = Integer.MIN_VALUE;	//取出最小值
		//int变量 ± long型常量 = long型数据
		System.out.println(max+1L);	//最大值加1
		System.out.println(min-(long)1);	//最小值减1
		//long变量 ± int型常量 = long型数据
		System.out.println((long)min - 2);	//最小值减2
	}
}

程序执行结果：

2147483648
-2147483649
-2147483650

以上案例程序首先取得了int数据类型的最大值与最小值，但是在进行计算时将两个int型的常量（“1L” “(long)1”）与一个int型变量（“(long)min”）转换为了long类型，由于long类型保存的数据范围较大，所以在计算时数据类型将统一自动转型为long型后再进行计算，此时就可以得出正确的计算结果。

以上代码利用数据的转型解决了数据的溢出问题。而除了可以将范围小的数据类型变为范围大的数据类型之外，也可以将范围大的数据类型变为范围小的数据类型，这种情况必须使用类型强制转换“（数据类型）数据”的格式完成。下面案例将演示如何将范围大的数据类型变为范围小的数据类型：

//案例8：使用类型强制转换来缩小数据类型
public class TestDemo{
	public static void main(String args[]){
		long num = 1000;	//1000常量是int型，使用long接受，发生了向大范围转型
		int x=(int) num;	//把long变为int
		System.out.println(x);
	}
}

程序执行结果：

此程序首先将一个int型常量1000赋值给long数据类型，由于long数据类型保存的数据范围要大于int数据类型，所以此处为自动转型，而后为了验证数据类型的向下转型，又将long数据类型强制变为int数据类型（(int)num）。

需要注意的是强制类型转换可能导致数据溢出问题。虽然程序支持强制类型转换，但是在将范围大的数据类型强制转换为范围小的数据类型时，依然要考虑该数据是否会发生溢出。以下案例就演示了类型强转时发生的数据溢出问题：

//案例9：类型强制转换时引发数据溢出问题
public class TestDemo{
	public static void main(String args[]){
		long num = 2147483650L;	//该数据已经超过了int数据范围
		intx = (int)num;	//把long变为int
		System.out.println(x);
	}
}

程序执行结果：

-2147483646

此程序首先定义了一个long数据类型的变量，并在变量声明时对其进行赋值，由于此时设置的数据“2147483650”已经超过了int范围，所以加上了“L”表示将此数值变为了long型。然后将long类型变量强制转换为int类型变量，但由于已经超过了int的数据保存范围，所以最终发生了数据的溢出。

🔍关于数据类型转换的规则？

在开发中数据类型的转换是经常使用到的概念，而数据类型的转换一般有以下规律。

数据范围小的数据与数据范围大的数据进行数学计算时，自动向大范围的数据类型转换后计算（例如：int类型和long类型计算，由于int类型保存范围小则自动变为long类型）；

数据范围大的数据要变为数据范围小的数据，必须采用强制转换，例如：long数据类型转换为int数据类型，由于int数据类型保存的范围要小于long数据类型，所以必须强制转换；

如果要强制性地将某一数据类型变为其他类型，则必须采用强制类型转换，例如：“(double) long型变量”，表示将long类型变量转换为double类型变量。

虽然在Java中提供了这样的转换原则，但从实际的开发来讲，建议尽量少去使用强制类型转换，以免造成数据精度的丢失以及数据功能性的破坏。这一点读者可以随着自己开发经验的提升而有更多的领悟。

在整型数据类型中，除了int与long这两个常用数据类型外，最为常用的就是byte数据类型了，byte数据类型的取值范围：-128～127。以下案例程序演示了byte类型的定义及取值范围：

//案例10：`byte`数据类型的取值范围
public class TestDemo{
	public static void main(String args[]){
		int num =130;	//此范围超过了byte定义
		byte x = (byte)num;	//由int变为byte
		System.out.println(x);
	}
}

程序执行结果：

-126

本程序首先定义了一个int型的变量，随后将此变量强制转型为byte型，由于此时num变量保存的数据值超过了byte的保存范围，那么最终会造成数据溢出问题。另外，考虑到byte数据类型较为常用，如果每次使用时都采用强制转换的方式比较麻烦，所以Java对其有一些很好的改善：

//案例11：Java对`byte`数据类型的优化
public class TestDemo{
	public static void main(String args[]){
		byte num=100;	//100没有超过byte的保存范围
		System.out.println(num);	//输出byte变量的内容
	}
}

程序执行结果：

从案例可以了解到，虽然任何一个整数都属于int型，但是Java编译时，如果发现使用的数据变量类型为byte，并且设置的内容在byte数据范围之内，就会自动帮助用户实现数据类型的转换。反之，如果超过了byte数据范围，则依然会以int型进行操作，此时就需要进行强制类型转换了。

虽然在Java中每个变量都有其默认值，但是这些默认值并不是在任何时候都可以使用（例如：方法中必须设置变量内容，而类中可以使用各个数据类型的默认值，这一点读者需要慢慢摸索），所以声明变量时最好的选择就是为其指派默认值。这是在JDK1.5之前的开发要求，在JDK1.5之后，Java考虑到程序的开发方便，允许在声明变量时不设置内容，但是要求在使用前必须设置内容。

//案例12：定义变量时不设置内容，使用变量前设置内容
public class TestDemo{
	public static void main(String args[]){
		int num;	//没有默认值
		num = 5;	//在使用此变量之前设置内容
		System.out.println(num);
	}
}

程序执行结果：

以上操作形式属于首先定义了一个变量num，但是此变量没有设置内容，然后设置了num变量的内容，最后再使用此变量。但是以上代码如果在JDK1.4及以前的版本是不可能编译通过的。因此最标准的做法是在定义变量的时候直接设置好默认值（int num=0;）。

4.2 浮点数

浮点数就是小数，Java中只要是小数，对应的默认数据类型就是double型数据，double也是取值范围最广的数据类型。以下案例演示了该类型的使用：

//案例13：定义浮点数
public class TestDemo{
	public static void main(String args[]){
		double num = 10.2;	//10.2是一个小数所以属于double型
		//double型 * int型（转化为double，3.0）= double型
		System.out.println(num*3);
	}
}

程序执行结果：

30.6

此程序首先声明了一个num的double型变量，然后利用此变量乘以一个值为3的int型常量，由于int数据类型保存的数据范围要小于double数据类型，所以int类型会自动转型为double类型，最后再参与计算。

由于默认的小数类型是double，所以如果使用float表示需要将double型变为float型，这时需要采用强制转换。转换的方式有两种：

使用字母“F”或“f”；
在变量或常量前使用“(float)”声明。

//案例14：使用float型浮点数
public class TestDemo{
	public static void main(String args[]){
		float f1 = 10.2F;		//小数都是double型，所以需要强制转换为float型
		float f2 = (float)10.2;		//小数都是double型，所以需要强制转换为float型
		System.out.println(f1*f2);	//float类型*float类型=float类型
	}
}

程序执行结果：

104.03999

此程序声明了两个float型变量，在声明变量时为其进行赋值，由于所有的小数默认类型都是double，需要进行强制类型转换，随后利用两个float型变量进行乘法计算。

🔍关于Java的计算的缺陷

可以发现，本程序的最终计算结果并不是期待的“104.04”，而是“104.03999”，这一问题本身属于Java的Bug（从JDK1.0开始的），只依靠计算本身无法解决，但是可以通过 Math或 BigDecimal两个高精度计算工具类来得到精确的结果，这部分知识会在后面的文章中做介绍。

实际上最早开发的时候，考虑到内存问题，往往能使用float就不使用double，例如：J2ME开发时，由于内存苛刻，所以往往会压缩数据范围，以节约空间。现在随着硬件成本的降低，是否使用double和float区别意义就不大了，可以直接使用double数据。需要注意的是，所有的数据类型只有double或float才可以保存小数。

//案例15：关于除法的问题
public class TestDemo{
	public static void main(String args[]){
		int x=9;	//声明整型变量
		int y=5;	//声明整型变量
		System.out.println(x/y);	//int型÷int型=int型
	}
}

程序执行结果：

此程序分别声明了两个int型变量（整型不能保存小数），而在进行除法计算时，根据两个int类型的变量计算后还是int类型这一定律，所以最终的计算结果是1，而不是正确的“1.8”。要想得出正确的计算结果，则可以将其中一个整型变为浮点类型：

//案例16：解决除法计算精度
public class TestDemo{
	public static void main(String args[]){
		int x=9;	//声明整型变量
		int y=5;	//声明整型变量
		System.out.println(x/(double)y);	//将其中一个int类型变量转换为double类型
	}
}

程序执行结果：

1.8

本程序在进行除法计算时，将变量y由int类型变为double类型，所以最终计算时变量x的类型也将自动转换为double类型，计算的结果就会包含小数数据。

4.3 字符型

在计算机中，byte代表字节的单位，按照传统的概念，一个字符通常由2个字节组成。对于字符而言，除了与字节之间有一些关联外，其主要关系在于与int类型变量的转换。

在计算机世界中，一切都以编码的形式存在。Java采用十六进制的UNICODE编码，这种编码可以表示任意字符。然而，在设计过程中考虑到与其他编程语言（如C/C++）的兼容性，该编码中包含了ASCII码的部分内容。因此，如果读者之前有类似的开发经验，对于Java的编码部分可以进行无缝衔接。

学习过C语言的读者，应该清楚在C语言中转换的编码是ASCII码，其编码范围如下：

大写字母范围：65～90；
小写字母范围：97～122。

大写字母和小写字母之间差了32，而Java的编码很好地继承了这一特性，即也可以按照此范围的编码表示常见的英文字母。在程序中使用单引号“'”声明的内容称为字符，每一个单引号里面只能够保存一位字符。

//案例17：定义字符型数据
public class TestDemo{
	public static void main(String args[]){
		char c = 'A';	//字符
		int num = c;	//字符可以和int型互相转换（以编码的形式出现）
		System.out.println(c);
		System.out.println(num);
	}
}

程序执行结果：

A
65

此程序首先定义了一个char型的变量c，而后将此字符型变量转换为int型变量，经过计算发现字母“A”的编码数值为65。

🔍一些常用编码范围

‘A’（65）～’Z’（90）；
‘a’（z97）～’z’（122）；
‘0’（48）～’9’（57）。

实际上字母“'A'”的编码值（65）要小于字母“'a'”的编码值（97），两者的编码值相差32，所以可以利用简单的数学计算来实现大小写转换。

//案例18：实现字母大小写转换
public class TestDemo{
	public static void main(String args[]){
		char c = 'A';		//大写字母
		int num = c;		//需要将字符变为int型才可以使用加法计算
		num = num+32;		//变为小写字母的编码
		c = (char)num;		//将int变为char型
		System.out.println(c);
	}
}

程序执行结果：

此程序首先定义了一个字符变量c，内容为字母“'A'”，然后为了可以实现大写变为小写的功能，将char型变量设置给int型变量，最后针对int变量num执行了加32的操作（'A’与’a’的编码值相差32），随后将int型转换为char型，所以最终的输出结果就是小写的字母“'a'”。

在传统的编程语言中，字符里面只能够保存一些英文字母的标记，但是在Java中，由于使用了UNICODE编码，这种十六进制的编码可以保存任意的文字，因此可以设置一个中文字符。

//案例19：利用字符变量保存中文
public class TestDemo{
	public static void main(String args[]){
		char c='王';	
		int num = c;	
		System.out.println(num);
	}
}

程序执行结果：

上边程序直接为字符设置了一个中文数据（只能是一个汉字），随后将其转换为int型数据，可以发现每一个中文在Java中都存在对应的UNICODE编码。

在最早的编程语言中，由于中文与英文字母所占的字节位数不同，在进行断句信息处理的时候，为了避免产生乱码问题（例如，在进行切割时将一个汉字拆成了两半，编码就会造成错误），往往需要进行编码范围的判断，操作过程会比较麻烦，但是在Java中由于英文与中文都使用了统一的UNICODE编码，所以此类问题也不再需要开发者做过多考虑。

4.4 布尔型

布尔型是一种逻辑结果，主要保存true、false两类数据，这类数据主要用于一些程序的逻辑使用。

//案例20：布尔值数据定义使用
public class TestDemo{
	public static void main(String args[]){
		boolean flag = false;		//布尔只有两种取值：true、false
		if(!flag){					//if(布尔值){满足条件的操作}
			System.out.println("Hello World.");
		}
	}
}

程序执行结果：

Hello World.

布尔型数据在大多数情况下都是用于程序逻辑控制的，所以在本程序中使用if分支结构来操作，在if分支结构中，如果判断的结果为true，则表示执行相应语句，如果为false，则表示不执行。

在许多的语言之中，由于设计的初期没有考虑到布尔型的问题，那么就使用了数字0表示false，而非数字0表示true（例如：1、2、3都表示true），但是这样的设计对于代码开发发比较混乱，Java里面不允许使用0或1来填充布尔型的变量内容。

4.5 字符串型

String表示的是一个字符串，即：多个字符的集合，String要求使用双引号“"”声明其内容。

与其他的几种基本数据类型相比，String属于引用数据类型（它属于一个类，在Java里面只要是类名称，每一个单词的首字母都是大写的），但是这个类的使用比较特殊。

//案例21：字符串定义使用
public class TestDemo{
	public static void main(String args[]){
		String str = "Hello World!";	//字符串变量
		System.out.println(str);		//输出字符串变量
		System.out.println("Hello World!");//输出字符串常量
	}
}

程序执行结果：

Hello World!
Hello World!

此序定义了一个String型的变量，随后将此变量进行输出，而为了进行对比，也同时输出了一个常量，通过本程序可以清楚使用“"”声明的内容就表示是一个String型的常量。在字符串的操作中，如果要改变内容，在次数不多的情况下可以使用“+”进行字符串拼接操作（操作次数多的情况使用更高效的StringBuffer、StringBuilder类，在后面文章会详细介绍）。

//案例22：字符串连接
ppublic class TestDemo{
	public static void main(String args[]){
		String str = "Hello";
		str=str + " World";	//字符串连接
		str += "!!!";		//字符串连接
		System.out.println(str);
	}
}

程序执行结果：

HelloWorld!!!

而在基本数据类型操作中，任何数据类型都向范围大的数据类型进行转换，如果是int和double，int应该先变为double，再进行加法计算。但是如果遇见了String这样特殊的引用类型，那么一切就变了，可以简单理解为，所有的数据类型如果遇见了String的“+”，那么所有的数据类型都先变为String型数据，再使用“+”进行连接运算。

在Java里面也支持多种转义字符的使用，例如：换行（\n）、制表符（\t）、\（\\）、双引号（\"）、单引号（\'）。

//案例23：转义字符
ppublic class TestDemo{
	public static void main(String args[]){
		String str= "Hello\"World\"\n\tHelloXiaoShan";
		System.out.println(str);
	}
}