第二章 基础语法
学习目标：
² 掌握 Java关键字和标识符
² 掌握 Java 的基本数据类型
² 掌握变量和常量
² 掌握 Java 代码的基本知识
² 掌握 Java 的运算符
² 掌握 Java 表达式
² 掌握 Java 流程控制结构
一：关键字
大家回忆一下我们在学习汉语的时候，开始学的是什么？肯定是先学一些单个的字，只
有认识了单个的字，然后才能组成词，然后才能慢慢的到句子，然后到文章。
学习同计算机交流跟这个过程是一样的，首先我们得学习一些计算机看得懂的单个的
字，那么这些单个字在Java 里面就是关键字。
1：什么是关键字
Java 语言保留的，Java 的开发和运行平台认识，并能正确处理的一些单词。
其实就是个约定，就好比我们约定好，我画个勾勾表示去吃饭。那好了，只要我画个勾
勾，大家就知道是什么意思，并能够正确执行了。
关键字这个约定在Java 语言和Java 的开发和运行平台之间，我们只要按照这个约定使
用了某个关键字，Java 的开发和运行平台就能够认识它，并正确地处理。
2：Java中有哪些关键字
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized enum
default if package this assert
3：Java中关键字的基本含义
• abstract：表明类或类中的方法是抽象的；
• boolean：基本数据类型之一，布尔类型；
• break：提前跳出一个块；
• byte：基本数据类型之一，字节类型；
• case：在switch语句中，表明其中的一个分支；
• catch：用于处理例外情况，用来捕捉异常；
• char：基本数据类型之一，字符类型；
• class：类；
• continue：回到一个块的开始处；
• default：用在 switch语句中，表明一个默认的分支；
• do：用在"do while"循环结构中；
• double：基本数据类型之一，双精度浮点数类型；
• else：在条件语句中，表明当条件不成立时的分支；
• extends：用来表明一个类是另一个类的子类；
• final：用来表明一个类不能派生出子类，或类中的方法不能被覆盖，或声明一个变量是常量；
• finally：用于处理异常情况，用来声明一个肯定会被执行到的块；
• float：基本数据类型之一，单精度浮点数类型；
• for：一种循环结构的引导词；
• if：条件语句的引导词；
• implements：表明一个类实现了给定的接口；
• import：表明要访问指定的类或包；
• instanceof：用来测试一个对象是否是一个指定类的实例；
• int：基本数据类型之一，整数类型；
• interface：接口；
• long：基本数据类型之一，长整数类型；
• native： 用来声明一个方法是由与机器相关的语言(如C/C++/FORTRAN 语言)实现的；
• new：用来申请新对象；
• package：包；
• private：一种访问方式：私有模式；
• protected：一种访问方式：保护模式；
• public：一种访问方式：公共模式；
• return：从方法中返回值；
• short：基本数据类型之一，短整数类型；
• static：表明域或方法是静态的，即该域或方法是属于类的；
• strictfp：用来声明FP-strict(双精度或单精度浮点数)表达式，参见 IEEE 754 算术规范；
• super：当前对象的父类对象的引用；
• switch：分支结构的引导词；
• synchronized：表明一段代码的执行需要同步；
• this：当前对象的引用；
• throw：抛出一个异常；
• throws：声明方法中抛出的所有异常；
• transient：声明不用序列化的域；
• try：尝试一个可能抛出异常的程序块
• void：表明方法不返回值；
• volatile：表明两个或多个变量必须同步地发生变化；
• while：用在循环结构中；
• assert：声明断言；
• enum：声明枚举类型；
4：解释几点
（1） ：这些关键字的具体含义和使用方法，会在后面用到的地方讲述
（2） ：Java 的关键字也是随新的版本发布在不断变动中的，不是一成不变的
（3） ：所有关键字都是小写的
（4） ：goto 和 const 不是 Java 编程语言中使用的关键字，但是是 Java 的保留字，也就是
说 Java 保留了它们，但是没有使用它们。true 和 false 不是关键字，而是 boolean 类型
直接量
（5） ：表示类的关键字是class
二：标识符
现在我们已经知道如何表述一个类了，那就是“class”这个关键字，那么属性和方法怎
么表达呢？我们是不是需要对每个属性和方法定义一个名字呢，比如：身高、体重等，这就
需要标识符了。
1：什么是标识符
在Java编程语言中，标识符是赋予变量、类或方法的名称。
2：标识符命名规则
命名规则如下：
（1） ：首字母只能以字母、下划线、$开头,其后可以跟字母‘下划线、$和数字
示例：$abc 、 _ab 、ab123 等都是有效的
（2） ：标识符区分大小写 （事实上整个Java 编程里面都是区分大小写的）
abc 和 Abc 是两个不同的标识符
（3） ：标识符不能是关键字
（4） ：标识符长度没有限制
3：标识符命名建议
（1） ：如果标识符由多个单词构成，那么从第二个单词开始，首字母大写
示例：isText 、 canRunTheCar 等
（2） ：标识符尽量命名的有意义，让人能够望文知意
（3） ：尽量少用带$符号的标识符，主要是习惯问题，大家都不是很习惯使用带$符号的
标识符；还有在某些特定的场合，$具有特殊的含义
（4） ：由于Java 语言使用Unicode 字符集，所以字母包括：
v ‘A’-‘Z’和‘a’-‘z’；
v Unicode字符集中序号大于 0xC0的所有符号；
v Unicode 字符集支持多种看起来相同的字母；
v 建议标识符中最好使用 ASCII字母
（5） ：标识符不应该使用中文，虽然中文标识符也能够正常编译和运行，其原因如上一
点讲到的：是把中文当作Unicode 字符集中的符号来对待了。
例如如下程序是可以正常编译和运行的，但是不建议这么做：
1 public class Test { 2 3 public static void main(String[] args) { 4 5 String Java私塾 = "中文标识符测试"; 6 7 System.out.println("Java私塾=="+Java私塾); 8 9 } 10 11 }
运行结果：Java私塾==中文标识符测试
4：示例一
下列哪些是正确的标识符：
1、myVariable 2、 9pinsn 3、 i 4、 a+c 5、testing1-2-3 6、java¨ 7、My Variable 8、It\'s
错误的标识符及其原因分析如下：
My Variable //含有空格
9pins //首字符为数字
a+c //加号不是字母
testing1-2-3 //减号不是字母
It\'s //单引号不是字母
java¨ //与号不是字母
5：示例二
好了，现在来用Java 代码表示前面抽象出来的人这个类，如下：
class Person{
//姓名
name;
//体重
weight;
//身高
height;
}
发现新的问题来了，我们定义的这个weight和 height 应该是有单位的，那么在 Java 中
怎么表达给weight和height设置单位呢？这就需要下面讲的数据类型了。
三：数据类型
1：什么叫数据类型
数据类型简单的说就是对数据的分类，对数据各自的特点进行类别的划分，划分的每种
数据类型都具有区别于其它类型的特征，每一类数据都有相应的特点和操作功能。例如数字
类型的就能够进行加减乘除的操作。
在现实生活中，我们通常会对信息进行分类，从而使得我们能很容易的判断某个数据是
表示一个百分数还是一个日期，我们通常是通过判断数字是否带”%”，或者是否是一个我们
熟悉的”日期格式”。
类似的在程序中，计算机也需要某种方式来判断某个数字是什么类型的。这通常是需要
程序员显示来声明某个数据是什么类型的，Java 就是这样的。Java 是一种强类型的语言，
凡是使用到的变量，在编译之前一定要被显示的声明。
2：Java数据类型的分类
Java 里面的数据类型从大的方面分为两类，一是基本数据类型，一是引用类型，基本的Java数据类型层次图如下：
3：Java中的基本数据类型
Java 中的基本数据类型分为八个原始数据类型，原始类型可分为四种：
（1） ：整数型：byte、short、int、long
（2） ：浮点型：float、double
（3） ：字符型：char
（4） ：逻辑型 ：boolean
3.1：整数型：byte、short、int、long
byte：字节型
short：短整型
int： 整型
long：长整型
在Java中，整数型的值都是带符号的数字，可以用十进制、八进制和十六进制来表示。
所谓多少进制， 就是满多少就进位的意思，如十进制表示逢十进位， 八进制就表示逢八进位。
示例：
15 ：十进制的15
O15 ：八进制的15，前面是数字0，相当于十进制的 13，计算公式：1*8+5=13
0x15：十六进制的15，相当于十进制的 21，计算公式：1*16+5=21
3.1.1：在 Java中的定义示例
示例1：byte abc = 5;
表示在Java 中定义一个变量abc，类型是byte类型，值是 5
同理可以定义其它的类型：
比如：
short abc1 = 5;
int abc2 = 5;
long abc3 = 5;
这些都是可以的，如果要明确表示是 long型的值，可以在后面直接跟一个字母“L” 。L
表示一个long 值。
也就是写成：long abc4 = 5L;
请注意，在 Java编程语言中使用大写或小写 L 同样都是有效的，但由于小写 l 与数字
1容易混淆，因而，尽量不要使用小写。
注意：整数型的值，如果没有特别指明，默认是 int 型
3.1.2 取值范围和默认值
取值范围的表示是按Java编程语言规范定义的且不依赖于平台
3.2：浮点型：float、double
Java用浮点型来表示实数，简单地说就是带小数的数据。
用 float 或 double 来定义浮点类型，如果一个数字包括小数点或指数部分，或者在数
字后带有字母F或f（float） 、D或d（double） ，则该数字文字为浮点型的。
示例：
12.3 //简单的浮点型数据
12.3E10 //数据很大的一个浮点数据
3.2.1：在 Java中的定义示例
如下定义都是可以的：
float abc = 5.6F;
float abc = 5.6f;
double abc = 5.6;
double abc = 5.6D;
double abc = 5.6d;
3.2.2：提示
（1） ：浮点型的值，如果没有特别指明，默认是 double 型的
（2） ：定义 float 型的时候，一定要指明是 float 型的，可以通过在数字后面添加”F”或者”f”
来表示。
（3） ：定义 double 型的时候，可以不用指明，默认就是 double 型的，也可以通过在数字后
面添加”D”或者”d”来表示。
3.2.3取值范围和默认值
Java技术规范的浮点数的格式是由电力电子工程师学会（IEEE）754 定义的，是独立于
平台的。可以通过Float.MAX_VALUE 和 Float.MIN_VALUE取得 Float的最大最小值；可以通
过Double.MAX_VALUE和Double.MIN_VALUE来取得Double 的最大最小值。
3.3：字符型：char
char 类型用来表示单个字符。一个 char 代表一个 16-bit 无符号的（不分正负的）
Unicode 字符，一个 char字符必须包含在单引号内。
示例：
‘a’ //表示简单的字符
‘1’ //用数字也可以表示字符
下面就错了，只能使用单个字符
‘ab’ //错误
‘12’ //错误
3.3.1：什么是Unicode编码
Unicode编码又叫统一码、万国码或单一码，是一种在计算机上使用的字符编码。它为
每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本
转换、 处理的要求。 1990 年开始研发， 1994年正式公布。 随着计算机工作能力的增强， Unicode
也在面世以来的十多年里得到普及。unicode的表达如下：
‘\u????’ 一个Unicode 字符。????应严格按照四个 16 进制数进行替换。
3.3.2：在 Java中的定义示例
char c = ‘a’;
char c = ‘1’;
3.3.3：取值范围和默认值
3.3.4：Java里面的转义字符
转义字符是指，用一些普通字符的组合来代替一些特殊字符，由于其组合改变了原来字
符表示的含义，因此称为“转义”。 常见的转义字符：
\n 换行(\u000a)
\t 水平制表符(\u0009)
\b 空格(\u0008)
\r 回车(\u000d)
\f 换页(\u000c)
\\' 单引号(\u0027)
\" 双引号(\u0022)
\\ 反斜杠(\u005c)
3.4：逻辑型：boolean
逻辑值有两种状态，即人们经常使用的“on”和“off” 或“true”和“false”或“yes”
和“no” ，这样的值是用 boolean类型来表示的。boolean有两个文字值，即true 和 false。
以下是一个有关boolean 类型变量的声明和初始化：
boolean truth = true; //声明变量 truth
注意──在整数类型和boolean类型之间无转换计算。有些语言（特别值得强调的是 C
和 C++）允许将数字值转换成逻辑值（所谓“非零即真” ）,这在 Java 编程语言中是不
允许的；boolean类型只允许使用 boolean 值（true或 false） 。
注意：Java中不可以直接将整数类型和逻辑类型转换
3.5：声明和赋值
3.5.1：什么是声明
声明为Java程序实体引入标识符，能够使用这些名字访问到这些实体，声明实体包括：
类名、属性名、方法名、变量名、参数名、接口名等等。其实简单点说就是定义某个东西并
对外宣称它。
3.5.2：什么是赋值
赋值就是为一个声明的变量或者常量赋予具体的值，也就是赋予值的意思。使用一个等
号”=”来表示。
示例：
int a = 5;
这句话的意思就是，声明一个类型为 int的变量 a，并将它赋值为 5。
3.6：特别介绍：字符串型 String
字符型只能表示一个字符，那么多个字符怎么表示呢？
Java 中使用String这个类来表示多个字符， 表示方式是用双引号把要表示的字符串引起
来，字符串里面的字符数量是任意多个。字符本身符合 Unicode 标准，且上述 char 类型的
反斜线符号 （转义字符） 适用于String。 与 C和 C++不同， String 不能用 \0 作为结束。 String
的文字应用双引号封闭，如下所示：
“The quick brown fox jumped over the lazy dog.”
char和String 类型变量的声明和初始化如下所示：
char ch = ‘A\'; // 声明并初始化一个字符变量
char ch1,ch2 ; //声明两个字符变量
// 声明两个字符串变量并初始化它们
String greeting = "Good Morning !! \n" ;
String err_msg = "Record Not Found !" ;
String str1,str2 ; // 声明两个字符串变量
String s = “12abc”; //基本的字符串型
String s = “”; //表示空串
注意：
（1） ：String 不是原始的数据类型，而是一个类(class)
（2） ：String包含的字符数量是任意多个，而字符类型只能是一个。
要特别注意： ”a” 表示的是字符串， 而’a’表示的是字符类型， 它们具有不同的功能。
（3） ：String的默认值是null
3.7：示例
下列程序显示了如何为整数、浮点数、boolean、字符和 String类型变量声明和赋值
1. public class Assign {
2. public static void main(String args []) {
3. int x, y; // 声明 int 变量
4.float z = 3.414f; // 声明并赋值 float
5.double w = 3.1415; //声明并赋值 double
6.boolean truth = true; //声明并赋值 boolean
7.char c; // 声明字符变量
8.String str; // 声明String 字符串
9.String str1 = "bye"; //声明并赋值 String 变量
10.c = \'A\'; // 给字符变量赋值
11.str = "Hi out there!"; // 给 String 变量赋值
12.x = 6;
13.y = 1000; // 给int 变量赋值
14....
15.}
16.}
非法赋值举例
y = 3.1415926; // 3.1415926 不是一个 int.
// 需要类型转换并且小数位要截掉
w = 175,000; // 逗号( , ) 不能够出现
truth = 1; // 一个优秀的 C/C++程序员常犯的错误，在 Java 语言中 boolean 型变量
只能为true或false
z = 3.14156 ; // double 型的值不能赋给 float 变量，需要类型转换
对于引用数据类型放到后面再学，先看看常量和变量。
四：常量和变量
1：什么是常量
常量是值不可以改变的标识符。
对常量的定义规则：建议大家尽量全部大写，并用下划线将词分隔。
如：JAVASS_CLASS_NUMBER ，FILE_PATH
2：什么是变量
变量是值可以改变的标识符，用来引用一个存储单元，用标识符来表示，可以通过操作
变量来操作变量所对应的内存区域或值块的值。
下面来理解一下：
2.1：变量是标识符
也就是说变量本质上是标识符， 但是所有的标识符都是变量吗？很显然不是的，那么哪
些标识符才是变量呢？
2.2：值可以改变
一定是值可以改变的这些标识符才被称为变量，注意是可以改变，不是一定要改变。
比如：
我们定义人的体重叫做 weight， 现在测量某人的体重是 70kg， 也就是weight的值是70，然后让他吃饭，吃完饭过后马上再次测量，此时体重可能是 71kg，也就是说 weight 的值发生了变化，变成了 71 了。对象并没有发生变化，属性也没有发生变化，只是这个属性的值发生了变化。
2.3变量的定义规则
（1） ：遵从所有标识符的规则
（2） ：所有变量都可大小写混用，但首字符应小写
（3） ：尽量不要使用下划线和$符号
（4） ：可以先声明再赋值，如：
int i;
i=9;
也可以声明的同时进行赋值:
int i=9;
2.4 几点说明
（1） ：变量在计算机内部对应着一个存储单元，而且总是具有某种数据类型：基本数据类型
或引用数据类型
（2） ：变量总是具有与其数据类型相对应的值
（3） ：每个变量均具有: 名字、类型、一定大小的存储单元以及值
五：Java 代码的基本知识
1：语句
用分号”;”结尾的一行代码就是语句，Java 中语句必须以”;”结尾。
如：int a = 10;
可以有块语句，例如：
1 int i=0; 2 3 { 4 5 int j = 0; 6 7 j = j+1; 8 9 } 10 11 i++;
2：块（block）
一个块是以{}作为边界的语句的集合，块可以嵌套。如：
1 { 2 3 int a = 10; 4 5 String s = “”; //一条语句或多条语句均可 6 7 { 8 9 System.out.println(“块可以嵌套”); 10 11 } 12 13 }
3：注释
什么是注释呢？就是标注解释的意思，主要用来对 Java 代码进行说明。Java 中有三种
注释方式
（1） ：// ：注释单行语句
示例：
//定义一个值为10 的int变量
int a = 10;
（2） ：/* */ ：多行注释
示例：
/*
这是一个注释，不会被Java 用来运行
这是第二行注释，可以有任意多行
*/
（3） ：/** */ ：文档注释
紧放在变量、 方法或类的声明之前的文档注释, 表示该注释应该被放在自动生成的文档
中(由javadoc命令生成的HTML 文件)以当作对声明项的描述。
示例：
/**
* 这是一个文档注释的测试
* 它会通过javadoc生成标准的 java接口文档
*/
常常在 javadoc 注释中加入一个以“@”开头的标记，结合 javadoc 指令的参数，可以
在生成的 API 文档中产生特定的标记
常用的javadoc标记
@author：作者
@version：版本
@deprecated：不推荐使用的方法
@param：方法的参数类型
@return：方法的返回类型
@see："参见"，用于指定参考的内容
@exception：抛出的异常
@throws：抛出的异常，和exception 同义
javadoc标记的应用范围
在类和接口文档注释中的标记有@see @deprecated @author @version
在方法或者构造方法中的标记有:@see @deprecated @param @return @exception
@throws
在属性文档注释中的标记:@see @deprecated
4：空格
在一个Java 程序中任何数量的空格都是允许的
5：Java编程基本的编码约定
可能有些还没有学到，没有关系，先了解一下。
类──类名应该是名词，大小写可混用，但首字母应大写。例如：
class AccountBook
class ComplexVariable
接口──接口名大小写规则与类名相同。
interface Account
方法──方法名应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写
字母将词分隔并限制使用下划线。例如：
balanceAccount( )
addComplex( )
变量──所有变量都可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划
线，限制使用美元符号（$） ，因为这个字符对内部类有特殊的含义。
currentCustomer
变量应该代表一定的含义， 通过它可传达给读者使用它的意图。 尽量避免使用单个字符，
除非是临时“即用即扔”的变量（例如，用 i, j, k作为循环控制变量）
常量──全部大写并用下划线将词分隔。
HEAD_COUNT
MAXIMUM_SIZE
控制结构──当语句是控制结构的一部分时，即使是单个语句也应使用括号（ ｛｝ ）将语句封闭。例如：
if (condition) ｛
do something
｝else ｛
do something else
｝
语句行── 每行只写一个语句并使用四个缩进的空格使你的代码更易读。
注释──用注释来说明那些不明显的代码段落；对一般注释使用 // 分隔符， 而大段的代码可使用 /*···*/分隔符。使用 /**···*/将注释形成文档，并输入给 javadoc 以生成HTML代码文档。
六：运算符
Java运算符很多，下面按优先顺序列出了各种运算符（ “L to R”表示左到右结合， “R
to L”表示右到左结合）
注意：运算符的结合性决定了同优先级运算符的求值顺序
1：算术运算
算术运算是指：＋、－、*、/ 等基本运算
需要注意的是：
％是求mod运算；
整数的除法要小心：
5/2 = 2 // 不是 2.5
2：比较运算
比较运算是指：>、<、>=、<=、==、!= 等类似运算
需要注意的是：
字符可以比较大小； （用它们的 ascii码，化为整数）
小心浮点数的相等比较
instanceof也是一个比较运算，用来判断一个对象是否属于某个类。 （以后介绍）
==运算中，对于基本类型是比较的“内容”，而对于引用类型，比较的是地址。 （小心）
3：逻辑运算
运算符&& (定义为“与”)和||（定义为“或” ）执行布尔逻辑表达式。请看下面的例子：
MyDate d = null;
if ((d != null) && (d.day() > 31)) ｛
// 利用d执行些什么
｝
形成 if ()语句自变量的布尔表达式是合法且安全的。这是因为当第一个子表达式是假
时，第二个子表达式被跳过，而且当第一个子表达式是假时，整个表达式将总是假，所以不
必考虑第二个子表达式的值。类似的，如果使用||运算符，而且第一个表达式返回真， 则
第二个表达式不必求值，因为整个表达式已经被认为是真。
4：++、---运算
++运算相当于：运算的变量加1，如：x++ 等同于 x=x+1;
--运算恰好相反，相当于运算的变量减1
注意：x++ 和 ++x 并不是一回事情。x++是先使用，然后再加；++x是先加然后再使用。
5：=赋值运算
x=5 相当于把5这个值赋给变量 x
6：位运算
位逻辑运算符（Bitwise Logical Operations） 。
算术逻辑运算符&（与） ，|（或） ，~（非） ，^（异或） ；
位运算示例
7：移位运算
Java 编程语言提供了两种右移位运算符和一种左移运算符，右移一位（ >> ）相对于
除以2：左移（ <<）相对于乘以2。
（1） ：运算符>>进行算术或符号右移位。移位的结果是第一个操作数被 2的幂来除，而
指数的值是由第二个数给出的。例如：
128 >> 1 gives 128/2
1
= 64
256 >> 4 gives 256/2
4
= 16
-256 >> 4 gives -256/2
4
= -16
（2） ：逻辑或非符号右移位运算符>>>主要作用于位图，而不是一个值的算术意义；它
总是将零置于符号位上。例如：
1010 ... >> 2 gives 111010 ...
1010 ... >>> 2 gives 001010 ...
在移位的过程中， >>运算符使符号位被拷贝。
PDF 文件使用 "pdfFactory Pro" 试用版本创建 www.fineprint.cnJava私塾跟我学系列——JAVA篇 网址：http://www.javass.cn 电话：010-68434236
（3） ：运算符<<执行一个左移位。移位的结果是：第一个操作数乘以 2 的幂，指数的值
是由第二个数给出的。例如：
128 << 1 gives 128*21= 256 <<2 gives 16*22 =64
（4） ：负数等于正数取反加一。
示例：
注意：
（1） ： 移位运算符将它们右侧的操作数模32简化为int类型左侧操作数, 模64简化为long
类型右侧操作数。因而, 任何int x, x >>> 32 都会导致不变的x 值, 而不是你可能预计的
零。
（2） ：值得称赞的重要一点是: >>>运算符仅被允许用在整数类型, 并且仅对 int 和 long
值有效。如果用在 short或byte值上, 则在应用>>>之前, 该值将通过带符号的向上类型转
换被升级为一个int。有鉴于此，无符号移位通常已成为符号移位。
8：用加号（+）进行串链接
运算符 + 能够进行String对象的链接并生成一个新的 String：
String salutation = "Dr. ";
String name = "Jack " + "Arthur";
String title = salutation + name;
最后一行的结果是：
Dr. Jack Arthur
如果+运算符中有一个自变量为 String 对象，则其它自变量将被转换成 String。所有
对象都可被自动转换成 String，尽管这样做的结果可能是意义含糊的。不是串的对象是通
过使用toString() 成员方法而转换成串的等价物的。
9：三目运算 ？：
三目运算符?:表达的是：判断问号前面的条件表达式是否为真，如果为真，返回冒号前面的值，否则返回冒号后面的值。
例如：
1 public class Test { 2 3 public static void main(String[] args) { 4 5 int i = (5>3) ? 6 : 7; 6 7 System.out.println("the i="+i); 8 9 } 10 11 }
运行结果为：the i=6
其实三目运算符的基本功能相当于 if-else（马上就要学到了） ，使用三目运算符是因为
它的表达比相同功能的if-else更简洁。上面的例子改成用 if-else表达如下：
1 public class Test { 2 3 public static void main(String[] args) { 4 5 int i = 0; 6 7 if (5 > 3) { 8 9 i = 6; 10 11 } else { 12 13 i = 7; 14 15 } 16 17 System.out.println("the i=" + i); 18 19 } 20 21 }
运行结果为：the i=6
七：控制语句
1： 分支控制语句
分支语句又称条件语句，条件语句使部分程序可根据某些表达式的值被有选择地执行。
Java编程语言支持双路if和多路switch分支语句。
1.1 if , else语句
if, else 语句的基本句法是：
if (布尔表达式)｛
语句或块；
｝ else ｛
语句或块；
｝
例如：
1 int count; 2 3 1.count = getCount(); // a method defined in the program 4 5 2.if (count < 0) { 6 7 3. System.out.println("Error: count value is negative."); 8 9 4.}else { 10 11 5. System.out.println("There will be " + count + 12 13 6. " people for lunch today."); 14 15 7.}
在Java编程语言中，if ()用的是一个布尔表达式，而不是数字值，这一点与 C/C++不
同。前面已经讲过，布尔类型和数字类型不能相互转换。因而，如果出现下列情况：
if (x) // x 是 int 型
你应该使用下列语句替代：
if (x ! = 0)
注意：
（1） ：if块和else块可以包含任意的java 代码，自然也就可以包含新的if-else，也就是
说：if-else是可以嵌套的，嵌套的规则是不可以交叉，必须完全包含。比如：
1 if(a1 > a2){ 2 3 if(a1 > a3){ 4 5 //包含在里面的块必须先结束 6 7 }else{ 8 9 //同样可以包含if-else块 10 11 } 12 13 }
（2） ：else部分是选择性的，并且当测试条件为假时如不需做任何事，else部分可被省略。也就是说if块可以独立存在，但是else块不能独立存在，必须要有 if 块才能有 else块。
（3） ：如果if块和else块的语句只有一句时，可以省略{}，例如：
1 if(a1 >ａ2) 2 3 System.out.println(“这是if块”); 4 5 else 6 7 System.out.println(“这是else块”);
上面的代码从语法角度是完全正确的，但是从代码的可阅读性上，容易让人产生迷惑，
所以我们不建议大家这么写。
（4） ：还可以把 else 和 if 组和使用，就是使用 else if，表达“否则如果”的意思，示
例如下：
1 if(a1 > a2){ 2 3 System.out.println(“a1 > a2”); 4 5 }else if(a1 > a3){ 6 7 System.out.println(“a1 > a3”); 8 9 }else if(a1 > a4){ 10 11 System.out.println(“a1 > a4”); 12 13 }else{ 14 15 System.out.println(“now is else”); 16 17 }再来个例子：
1 if (score>=90){ 2 3 grade= "very good"; 4 5 }else if(score>=70){ 6 7 grade= "good"; 8 9 }else if (score>=60){ 10 11 grade= "pass"; 12 13 }else{ 14 15 grade= "No pass"; 16 }（5） ：如果不用“{ }” ，则“else”总是与最接近它的前一个 “if”相匹配
例如:
1 if ( x > 5 ) 2 3 if ( y > 5 ) 4 5 System.out.println( "x and y are > 5" ); 6 7 else 8 9 System.out.println( "x is <= 5" );执行与上面的对应匹配形式不同，而是与下面形式匹配
1 if ( x > 5 ) 2 3 if ( y > 5 ) 4 5 System.out.println( "x and y are > 5" ); 6 7 else 8 9 System.out.println( "x is <= 5" );
1.2 switch语句
switch 表示选择分支的情况，switch 语句的句法是：
1 switch (expr1)｛ 2 3 case expr2: 4 5 statements; 6 7 break; 8 9 case expr3: 10 11 statements; 12 13 break; 14 15 default: 16 17 statements; 18 19 break; 20 21 ｝
说明：
（1） ：switch 的表达式 expr1 只能是整数型的值或者 enum 枚举类型的常量值，包含
byte、short、int和char，不能是字符串或对象，也不能是 long型的值。
（2） ：当变量或表达式的值不能与任何 case值相匹配时，可选缺省符（default）指出
了应该执行的程序代码。
例1：
public class Test { public static void main(String[] args) { int colorNum = 5; switch (colorNum) { case 0: System.out.println(Color.red); break; case 1: System.out.println(Color.green); break; default: System.out.println(Color.black); break; } } }
运行结果：java.awt.Color[r=0,g=0,b=0]
（3） ：如果没有 break语句作为某一个 case 代码段的结束句，则程序的执行将继续到
下一个case，而不检查 case表达式的值。
例2：
1 public class Test { 2 3 public static void main(String[] args) { 4 5 int colorNum = 0; 6 7 switch (colorNum) { 8 9 case 0: 10 11 System.out.println(Color.red); 12 13 case 1: 14 15 System.out.println(Color.green); 16 17 default: 18 19 System.out.println(Color.black); 20 21 break; 22 23 } 24 25 } 26 27 }
运行结果：
java.awt.Color[r=255,g=0,b=0]
java.awt.Color[r=0,g=255,b=0]
java.awt.Color[r=0,g=0,b=0]
例 2 设定背景颜色为黑色，而不考虑 case 变量 colorNum的值。如果 colorNum的值为
0，背景颜色将首先被设定为红色，然后为绿色，再为黑色。
2： 循环控制语句
循环语句使语句或块的执行得以重复进行。 Java编程语言支持三种循环构造类型： for,
while和 do 循环。for和while循环是在执行循环体之前测试循环条件，而do 循环是在执
行完循环体之后测试循环条件。这就意味着 for和 while循环可能连一次循环体都未执行，
而do 循环将至少执行一次循环体。
2.1 for循环
for循环的句法是：
for (初值表达式; boolean 测试表达式; 改变量表达式)｛
语句或语句块
｝
例如：
1 for (int i = 0; i < 10; i++) { 2 3 System.out.println("Are you finished yet?"); 4 5 } 6 7 System.out.println("Finally!");
注意：for语句里面的3个部分都可以省略，但是我们不建议这么做。
示例如下：
示例1：就是一个无限循环
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for(;;){ 6 7 System.out.println("Java私塾"); 8 9 } 10 11 } 12 13 }
示例2：可以省略部分
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for(int i=0;;){ 6 7 System.out.println("Java私塾"+i); 8 9 } 10 11 } 12 13 }
示例3：可以省略部分
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for(int i=0;i<3;){ 6 7 System.out.println("Java私塾"+i); 8 9 } 10 11 } 12 13 }
示例4：可以省略部分
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for(int i=0;;i++){ 6 7 System.out.println("Java私塾"+i); 8 9 } 10 11 } 12 13 }
当然还有其他的组合方式，都是可以的。
2.2 while循环
while循环的句法是：
while (布尔表达式) ｛
语句或块
｝
例如：
1 int i = 0; 2 3 while (i < 10) { 4 5 System.out.println("Are you finished yet?"); 6 7 i++; 8 9 }; 10 11 System.out.println("Finally!");
请确认循环控制变量在循环体被开始执行之前已被正确初始化， 并确认循环控制变量是
真时，循环体才开始执行。控制变量必须被正确更新以防止死循环。
2.3 do循环
do循环的句法是：
do ｛
语句或块；
｝while (布尔测试);
例如：
1 int i = 0; 2 3 do { 4 5 System.out.println("Are you finished yet?"); 6 7 i++; 8 9 } while (i < 10); 10 11 System.out.println("Finally!");
像 while 循环一样，请确认循环控制变量在循环体中被正确初始化和测试并被适时更
新。作为一种编程惯例，for循环一般用在那种循环次数事先可确定的情况，而 while和 do
用在那种循环次数事先不可确定的情况。
do循环与while循环的不同这处在于，前者至少执行一次，而后者可能一次都不执行。
2.4 特殊循环流程控制
下列语句可被用在更深层次的控制循环语句中：
l break ［标注］；
l continue［标注］；
l label: 语句；//这里必须是任意的合法的语句
break 语句被用来从 switch 语句、循环语句和预先给定了 label 的块中退出，跳出离
break最近的循环。
continue语句被用来略过并跳到循环体的结尾，终止本次循环，继续下一次循环。
label 可标识控制需要转换到的任何有效语句，它被用来标识循环构造的复合语句。它
类似以前被人诟病的”goto”语句，我们应该尽量避免使用。
例1：break的使用
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for (int i = 0; i < 10; i++) { 6 7 if (i == 5) { 8 9 break; 10 11 } 12 13 System.out.println("i==" + i); 14 15 } 16 17 } 18 19 }
运行的结果：i==0一直到i==4
因为当i==5的时候，执行break，跳出for 循环。
例2：continue的使用
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for (int i = 0; i < 5; i++) { 6 7 if (i == 3) { 8 9 continue; 10 11 } 12 13 System.out.println("i==" + i); 14 15 } 16 17 } 18 19 }
运行的结果：i==0一直到i==4，就是不包括i==3。因为当 i==3的时候，执行 continue，
终止本次循环，继续下一次循环。
例3：label的使用
1 public class Test { 2 3 public static void main(String[] args) { 4 5 L: for (int i = 0; i < 5; i++) { 6 7 if (i == 3) { 8 9 break L; 10 11 } 12 13 System.out.println("i==" + i); 14 15 } 16 17 } 18 19 }
运行的结果是：i==0一直到i==2
例4：label的使用
1 public class Test { 2 3 public static void main(String[] args) { 4 5 for (int i = 0; i < 5; i++) { 6 7 L:if (i == 3) { 8 9 break L; 10 11 } 12 13 System.out.println("i==" + i); 14 15 } 16 17 } 18 19 }
运行的结果是：i==0一直到i==4
作业
1：叙述标识符的定义规则，指出下面的标识符中那些是不正确的，并说明理由
here , _there, this, it, 2to1, _it
2：Java中共有那些基本数据类型？分别用什么符号来表示，各自的取值范围是多少？
3：复习所有的 Java关键字
4：指出正确的表达式
A byte b=128;
B char c=65536;
C long len=0xfffL;
D double dd=0.9239d;
5：下面哪几个语句将引起编译错?
A. float f=4096.0;
B. double d=4096.0;
C. byte b=4096;
D. char c=4096;
6：简述Java 中的运算符，以及他们的运算次序。
7：创建一个switch 语句，为每一种case 都显示一条消息。并将 switch 置入一个 for
循环里，令其尝试每一种case。在每个 case后面都放置一个 break，并对其进行测试。
然后，删除break，看看会有什么情况出现。
8：执行下列代码后的x和y的结果分别是什么?
int x,y,a=2;
x=a++;
y=++a;
9：下面的程序输出结果是：a=6 b=5
请将程序补充完整。
1 public class A 2 3 { 4 5 public static void main(String args[]) 6 7 { 8 9 int a=5,b=6; 10 11 a= ______; 12 13 b=a-b; 14 15 a=_______; 16 17 System.out.println("a="+a+" b="+b); 18 19 } 20 21 }
10：下面哪个语句序列没有错误，能够通过编译？
A. int i=0; if (i) { System.out.println(“Hi”); } B. boolean b=true; boolean b2=true; if(b==b2) { System.out.println(“So true”); } C. int i=1; int j=2; if(i==1|| j==2) System.out.println(“OK”); D. int i=1; int j=2; if (i==1 &| j==2) System.out.println(“OK”);
11：阅读以下代码行：
boolean a=false; boolean b=true; boolean c=(a&&b)&&(!b)； int result=c==false?1:2; 这段程序执行完后，c与result的值是： A c=false; result=1; B c=true; result=2; C c=true; result=1; D c=false; result=2;
12：下列代码哪行会出错？
1) public void modify() { 2) int i, j, k; 3) i = 100; 4) while ( i > 0 ) { 5) j = i * 2; 6) System.out.println (" The value of j is " + j ); 7) k = k + 1; 8) i--; 9) } 10) } A 第 4行 B 第 6行 C 第 7行 D 第 8行
13：指出下列程序的运行结果。
int i = 9; switch (i) { default: System.out.print("default"); case 0: System.out.print("zero"); break; case 1: System.out.print("one"); case 2: System.out.print("two"); } A default B defaultzero C 编译错 D 没有任何输出
往下是编程题：
14: 将1 到1000 之间的奇数打印出来。
15: 判断一个数能否同时被3和5整除。
16: 输入 10个数，找出最大一个数，并打印出来。
17: 给出一百分制成绩，要求输出成绩等级’A’,’B’,’C’,’D’,’E’。90 分以上
为’A’,80~89分为’B’,70~79 分为’C’,60~69分为’D’,60分以下为’E’。
18: 输出图案：
*
**
***
****
19: 使用for 语句打印显示下列数字形式：n=4
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1