第 2章 方法设计
类由类的首部和类体构成，而类体又由类的成员变量和
成员方法构成。方法是对客体行为的描述
第 2章 方法设计
?方法的基本概念
?运算符与表达式
?流程控制语句
?算法设计举例
方法的基本概念
?Java类由状态（或属性）和行为两部分组成。
?属性是保存描述类对象状态数据的途径，但
属性并不具备任何活动能力。一个类要真正
能完成一定的操作，就必须为类创建行为。
?行为描述了该类需要完成的每项具体任务所
用的不同程序段，每个这样的就叫做“方法”
方法分类
?在 Java程序中，用“数据”来描述类的属性，
用“方法”来实现类的行为。
?方法可分为成员方法（ instance method）和
类方法（ class method，即由 static修饰的方
法，又叫做静态方法）两种
方法的声明
?描述方法的处理过程及其所需的参数，并用
一个方法名来标识这个处理过程
?方法定义中的参数并没有实际值，仅仅是为
了描述处理过程而引入的，因此称为 形式参
数 （简称 形参 ）
方法的使用
?通过向客体发送消息执行方法所定义的处理
功能。使用方法时给出参数的实际值，这些
实际值称为 实际参数 （简称 实参 ）
方法首部的声明
? 语法形式如下,
? [方法修饰符 ] 方法返回值类型 方法名 （ [形式参数表 ]）
? 其中,
? 方法修饰符 可以是 static,final以及 public,private和
protected等。 static,final本书不作专门介绍，“方法修饰
符”是可选的语法部分。
? 方法返回值类型 说明方法返回值的数据类型，可是 Java基本
数据类型，也可是复合数据类型。 当无返回值时，其返回值
类型须说明为 void。
? 方法名 标识所声明的方法，必须是合法的 Java标识符；
? 形式参数表 说明方法所需要的参数，当方法有多个参数时，
参数间需用逗号“，”隔开；当方法没有参数时，可以没有
“形式参数表”部分。形式参数的作用域是整个方法体。
方法体
?方法体是一个语句序列，这一语句序列具体
描述方法的返回值、方法的参数和方法所在
类的成员变量之间的关系，以实现方法的功
能。
?方法体中可以定义其内部使用的局部变量，
其作用域是整个方法体。
方法的返回值
?若方法的返回值类型不是 void时，方法体中
必须用 return语句来返回一个方法声明时指定
类型的值。
?return 语句的语法形式为,
return [表达式 ] ；
?其中,return是关键字。
方法声明的例子
? 方法 setCNumber,
? void setCNumber (int xNumber)
// 方法首部声明：无方法修饰符，方法名为
//setCNumber，方法的参数为 xNumber，这一方法
//无返回值
? { //方法体开始
? cNumber = xNumber;
//方法体中的语句，描述方法的功能
? } //方法体结束
方法 getCNumber
? int getCNumber( )
//方法首部声明：无方法修饰符，方法名为
//getCNumber，这一方法无参数，这一方法
//的返回值类型为 int
? { //方法体开始
? return cNumber;
? //将 cNumber的值作为 getCNumber方法的返回值
? } //方法体结束
方法的调用与参数传递
?调用对象成员方法的语法形式为,
对象名, 成员方法名 （ [实际参数表 ]）；
?对象名 指定所使用的对象；
?成员方法名 指定所要调用的成员方法；
?实际参数表 是 0个或多个表达式构成，多个表
达式之间用逗号“，”分隔。实际参数的个
数、顺序及类型应与被调用方法的形式参数
表中的形式参数一致。
调用对象成员方法的语义
?计算实际参数表中（各）表达式的值，并将
它（们）一一传送给被调用方法中对应的形
式参数，执行被调用方法的方法体。
?方法调用的结果就是被调用方法的执行结果
实现两 float型数相加的方法例子
class MethodDemo1{
float add(float x,float y)
//建议所取的方法名有助于说明方法的功能，以便阅读程序和记忆
{
float z;
// z是方法体的局部变量，作用域是整个 add方法的方法体
z = x + y;
return z;
}
}
class TryMethodDemo1{ //主类
public static void main(String args[ ]){
MethodDemo1 a = new MethodDemo1( );
System.out.println(a.add(5,8));
}
}
实现两 float型数相加的方法例子二
class ObjPara { //定义对象作为参数的类，为便于举例，本方法只有一个成员变量
float temp;
}
class MethodDemo2{
void add(float x,float y,ObjPara z){ //方法首部声明，此方法没有返回值 。
z.temp = x + y; //将 x+y的结果存入类变量 z的成员变量 temp中 。
}
}
class TryMethodDemo2{ //主类
public static void main(String args[ ]){
ObjPara b = new ObjPara( );
MethodDemo2 a = new MethodDemo2( );
a.add(4,6,b);
System.out.println(b.temp);
}
}
演示方法之间的消息发送与参数传递
class MethodDemo3{
float add(float x,float y){
float z;
z = x + y;
return z; }
void callAdd(float m,float n){
float t;
t = add(m,n);
/*向方法 add发消息，将参数 m,n的值分别传递给 x,y，然后执行
方法 add的方法体，计算 x+y，计算结果作为 add的返回值传回给 t*/
System.out.print(m+"+"+n+"="+t); }
}
class TryMethodDemo3{ //主类
public static void main(String args[ ]){
MethodDemo3 a=new MethodDemo3( );
a.callAdd(4,6); }
}
方法间的消息发送与参数传递演示 二
class ObjPara{
float temp;}
class MethodDemo4{
void add(float x,float y,ObjPara z){
z.temp = x + y; }
void callAdd(float m,float n){
ObjPara k = new ObjPara();
add(m,n,k);
/*向方法 add发消息，将参数 m,n的值分别传递给 x,y,并将 k的存储地址值传送给 z，
然后执行方法 Add的方法体，计算 x+y，计算结果通过对象 k的成员 temp传回 */
System.out.print(m+"+"+n+"="+k.temp);
} // k.temp的值即为 m+n
}
class TryMethodDemo4{ //主类
public static void main(String args[ ]){
MethodDemo4 a = new MethodDemo4( );
a.callAdd(4,6); }
}
2.2 运算符与表达式
?1 赋值运算
?2 算术运算
?3 关系运算
?4 逻辑运算
?5 位运算符
?6 三元运算
?7 其它运算符
基本定义
?对数据进行的操作称为 运算
?表示各种不同运算的符号称为 运算符
?参于运算的数据称为 操作数（ operand）
?表达式（ Expression） 是由操作数和运算符
按一定的语法形式组成的符号序列
?通过算术运算符将运算对象连接起来的式子，
就称为 算术表达式
Java语言的运算符
分类 运算符 结合性
一元运算符 + － ++ - - ！ ~ ( ) * 右
算术运算符 * / % 左 + －
移位运算符 << >> >>> 左
比较运算符 < <= > >= instanceof 左 = = !=
按位运算符
&
左 ^
|
短路运算符 && 左 | |
条件（三元）运算符?, 右
赋值运算符 =,op=”（复合赋值运算符） 右
1 赋值运算
?给新定义的变量进行初始化或修改变量的内
容需要用到赋值运算。
?赋值运算的一般形式为,
变量 = 表达式 ;
复合赋值运算符
?在赋值运算符,=”之前加上其它运算符 <op>，
就构成了 复合赋值运算符, <op>=”
?复合赋值运算符,<op>=”集成了计算和赋值
两大功能，对于任何类型兼容的表达式 x和 y
来说,x <op>= y
?复合赋值运算符包括,*=,/=,%=,+=、－
=,<<=,>>=,>>>=,&=,^=和 |=
2 算术运算
?算术运算符作用于整型或浮点型数据，完成
算术运算。
?按操作数个数来分，有 一元算术运算符 和 二
元算术运算符
一元算术运算符
运算符 用 法 描 述
+ +op 正值
- -op 负值
++ ++op或 op++ 加 1
- - - -op或 op- - 减 1
++和 - -算术运算符
?称为增一运算符和减一运算符
?可以作为前缀运算符
?可以作为后缀运算符
++和 --运算符及用法
运算符 用法 描 述
++ x++ 表达式 x++的值为 x，然后 x的值增 1
++ ++x 表达式 ++x的值为 x+1,x的值增 1
-- x-- 表达式 x--的值为 x，然后 x的值减 1
-- --x 表达式 --x的值为 x-1,x的值减 1
二元算术运算符
运算符 用 法 描 述
+ op1 +op2 操作数 op1加上 op2
- op1-op2 操作数 op1减去 op2
* op1 * op2 操作数 op1乘以 op2
/ op1 / op2 操作数 op1除以 op2
% op1 % op2 求操作数 op1除以 op2的余数（取模）
?整数算术运算的除法和取模遵循以下等式
（ a/b） *b+（ a%b） = =a
?对于浮点算术运算来说
a%b和 a-（（ int）（ a/b） *b）的语义相同
?在取模运算时，假设操作数中至少有一个负
数，那么一般采取这样一个有用的规则
先忽略掉所有操作数的符号来计算得到结果，
然后将,%”左边的操作符的符号赋给它得到
最终答案
一个算术运算的例子
public class ArithmaticOp{
public static void main( String args[ ] ){
int a = 5,b = 3;
int c = ++a / b;
int c2 = a-- / b;
int c3 = a * 2 % b;
double d = 2.5;
double d2 = d % 3;
System.out.println("c=" + c);
System.out.println("c2=" + c2);
System.out.println("c3=" + c3);
System.out.println("d2=" + d2);
}
}
3 关系运算
?关系运算实际上就是比较运算，它的运算结
果是一个布尔类型的值。
?如果两个运算对象符合关系运算符所要求的
比较关系，则关系运算结果为 true，否则为
false。
?Java语言提供的关系运算符都是二元运算符
关系运算符
运算符 用 法 功 能
> op1 > 0p2 如果 op1大于 op2则结果为 true，否则为 false
>= op1 >= op2 如果 op1大于或等于 op2则结果为 true，否则为 false
< op1 < op2 如果 op1小于 op2则结果为 true，否则为 false
<= op1 <= op2 如果 op1小于或等于 op2则结果为 true，否则为 false
= = op1 = = op2 如果 op1等于 op2则结果为 true，否则为 false
!= op1 != op2 如果 op1不等于 op2则结果为 true，否则为 false
关系表达式
?用关系运算符将两个相同类型的表达式连接
起来的的式子，称为 关系表达式
3>5
?a?<?z?
x+y!=z
?都是合法的关系表达式
赋值（,=”）和等价比较（,= =”）
? 关系运算符 (<,<=,>,>=)一般适用于两侧的操作
数均为整数型、浮点型或字符型数据的情形，布尔
型数据只能用在 = =或 !=比较中。
? 关系运算符 (<,<=,>,>=)连接的表达式本身不能
是关系表达式。例如,x>y>z是非法的。
? 关系运算的结果不能存放在一个非布尔型变量中
一个关系运算的例子
public class RelationOp
{
public static void main( String args[ ] )
{
int a=25,b=3;
boolean d = a > b;
boolean d1=3.5 < 2.6;
boolean d2='A' <= 'A';
boolean d3 = false != true;
boolean e = a >= a * 2 - b * 9;
System.out.println("d= "+ d);
System.out.println("d1= "+ d1);
System.out.println("d2= "+ d2);
System.out.println("d3= "+ d3);
System.out.println("e= "+ e);
}
}
4 逻辑运算
?关系运算 只能表示一个简单的条件，而 逻辑
运算 可以将几个关系表达式或者布尔值连接
起来，表示一个较复杂的条件
?逻辑运算 的运算对象必须是布尔值类型的表
达式，运算结果也是布尔值类型的数据
逻辑运算符
运算符 用 法 功 能 分类
!（逻辑非） !op1 op1为 true，则结果为 false，否则为true。 一元
&&（逻辑与） op1 && op2 op1和 op2都为 true，则结果为 true，否则为 false。
二元
||（逻辑或） op1 || op2 op1和 op2都为 false，则结果为 false，否则为 true。
逻辑运算的真值表
x y !x !y x && y x || y
true true false false true true
true false false true false true
false true true false false true
false false true true false false
短路运算符
?,&&”和,||“又叫做 短路运算符
? 在由它们连接组成的逻辑表达式的求解过程中，总
是先求出运算符左边的表达式的值，再根据具体情
况决定是否需要计算运算符右边的表达式
? 对,||”运算，如果左边的表达式的值为 true，则不
必对运算符右边的表达式再进行运算，整个表达式
的结果就为 true
? 对,&&”运算，如果左边的表达式的值为 false，则
不必对运算符右边的表达式再进行运算，整个表达
式的结果就为 false。
关系运算符和逻辑运算符共用的例子
public class RelationAndConditionOp{
public static void main(String args[ ]){
int a = 28,b = 3;
int e = 3;
if(e != 0 && a/e>5)
System.out.println("a/e="+a/e);
int f=0;
//下面不会发生除零溢出的错误，因为 e!=0为 false，所以不需要对 a/f进行运算。
if(f!=0 && a/f>5)
System.out.println("a/f="+a/f);
else
System.out.println("f="+f);
}
}
5 位运算符
?位运算符用来对二进制位进行操作，其操作
数只能为整型或字符型数
?提示：在 Java中，使用补码来表示二进制数，
最高位为符号位，正数的符号位为 0，负数的
符号位为 1
位运算符
运算符 用 法 描 述 分类
~ ~ op1 按位取反运算
按位运算符
一元
& op1& 0p2 按位与运算
二元
| op1| 0p2 按位或运算
^ op1^ 0p2 按位异或运算
<< op1<< 0p2 左移运算
移位运算符 >> op1>> 0p2 带符号右移运算
>>> op1>>> 0p2 不带符号右移运算
4种按位运算
?“~”是按位取反运算符
?,&”是按位与运算符
?,|”是按位或运算符
?,^”是按位异或运算符
按位取反运算符
?对数据的每个二进制位取反，即把 1变成 0，
把 0变成 1。
?例如,
~00001111=11110000
“&”是按位与运算符
?要求有两个操作数进行运算。如果两个相应
位均为 1，则该位的结果为 1，否则结果为 0。
即,
0&0=0 0&1=0
1&0=0 1&1=1
?提示,
对某个数中某些特定的位清零
用来取某个数中某些指定的位
“|”是按位或运算符
?只要两个相应位中有一个为 1，则该位的结果
为 1，否则结果为 0。即,
0|0=0 0|1=1
1|0=1 1|1=1
?提示,
按位或运算可以用来将某个数中某
些特定的位置 1
“^”是按位异或运算符
?同样要求有两个操作数进行运算。如果两个
相应位相同，则该位的结果为 0，否则结果为
1。即,
0^0=0 0^1=1
1^0=1 1^1=0
?提示,
用来使某个数中某些特定的位取反
实现两个值的交换，而不需使用临时变量
布尔型操作数上时的运算规则
Op1 Op2 Op1& Op2 Op1| Op2 Op1^ Op2
true true true true false
true false false true true
false true false true true
false false false false false
其它 3种移位运算
?（ a）左移运算 (<<)
?（ b）带符号右移运算 (>>，又称为算术右移 )
?（ c）不带符号的右移运算 (>>>，又称为逻辑
右移 )
移位运算的例子
x（十进制表示） x的二进制补码表示 x<<2 x>>2 x>>>2
30 00011110 01111000 00000111 00000111
-17 11101111 10111100 11111011 00111011
6 三元运算
?条件运算符,?:”比较特殊，是 Java语言中仅
有的一个三元运算符，它的一般形式为,
表达式 1? 表达式 2,表达式 3
?其中表达式 e1的值必须是布尔值类型，如果
该值为 true，则对表达式 e2进行求值，并将
e2的求值结果作为整个表达式的值；否则对
表达式 e3进行求值并将 e3的结果作为整个表
达式的值。
一个条件运算符的例子
/*编程从三个整数 x,y,z中选出最大和最小者。 */
class Max2{
public static void main(String args[ ]){
int x = 335;
int y = 212;
int z = 38;
int a,b,max,min;
System.out.println(" 原来的整数的值为,x="+x+",y="+y+",z="+z);
a = (x > y? x, y);
max = (a > z? a, z);
b = (x < y? x, y);
min = ( b < z? b, z);
System.out.println(" 最大的元素的值为," + max);
System.out.println(" 最小的元素的值为," + min);
}
}
7 其它运算符
?这里主要介绍对象运算符 instanceof
?它也可以说是一种比较运算符，用来判断一
个运行时的对象是否属于某个指定类或其子
类的实例，如果是则返回 true，否则返回
false
?其一般形式为,
对象名 instanceof 类名
对象运算符的用法
public void method (Employee e) {
if ( e instanceof Manager ) {
… //do something as a Manager
}
else if ( e instanceof Contractor ) {
… //do something as a Contractor
}
else {
… //do something else
}
}
2.3 流程控制语句
语句类型 关键字
循环 while,do-while,for
选择 if-else,switch-case
转向控制 break,continue,label:,return
*异常处理 try-catch-finally,throw
重点说明流程控制语句
?1 循环结构（ Loop Constructs）
?2 选择语句（ Selection Statements）
Loop Constructs
?循环的作用是反复执行同一块代码直到满足
结束条件
?三种循环语句,
1） while 语句
2） do-while语句
3） for语句
while 语句
?while 语句实现“当型”循环，它的语法形式
为,
while (布尔表达式 )
循环体
while 语句用于在布尔表达式（即测试条件）的值保持为真（ true）时反复地执
行其中的内嵌语句（一般叫做循环体）
while 语句的流程图
循 环 体
布尔表达式
true
例 求 100以内所有奇数的和
public class WhileDemo {
public static void main(String[ ] args) {
int i,sum;
sum = 0; //计数器清 0
i = 1; //i的初始值为 1（因为 1是最小的奇数）
while (i <= 100){
sum += i;
i += 2; //奇数的间隔为 2
}
System.out.println(sum);
}
}
do-while语句
?do-while 语句实现“直到型”循环，它的语
法形式如下,
do
循环体
while (布尔表达式 );
do-while 语句执行的过程为：先执行一次循环体中的语句，然后测试布
尔表达式的值。如布尔表达式的值为真，那就返回执行循环体中的内容
do-while 语句的流程图
布尔表达式
循 环 体
false
true
例 求 100以内所有奇数的和
public class DoWhileDemo {
public static void main(String[ ] args) {
int i,sum;
sum = 0; //计数器清 0
i = 1; //i的初始值为 1
do{
sum += i;
i += 2;
}while (i<=100);
System.out.println("sum=" + sum);
}
}
do-while 语句和 while语句的不同之处
?do-while 语句总是先进入循环，然后检测条
件，再决定是否继续循环
?while 语句是先测试条件，再决定是否进入循
环
?所以，用 do-while 语句时，循环体至少执行
一次。
体会 while 语句
public class WhileDemo2{
public static void main(String[ ] args){
int i = 88;
while ( i < 88){
System.out.println("Print " + i);
i++;
}
}
}
此例的运行结果是什么也不输出
体会 do-while语句
public class DoWhileDemo2{
public static void main(String[ ] args){
int i = 88;
do{
System.out.println("Print " + i);
i++;
}while (i < 88);
}
}
此例的运行结果是,Print 88
for语句
?实现“当型”循环，它的语法形式为,
for (表达式 1； 表达式 2； 表达式 3)
循环体
每个 for语句都有一个用于决定循环开始和结束的变量，通常
称这个变量为 循环控制变量
for 语句的执行过程
?先求解表达式 1；
?求解表达式 2，若其值为 true，则执行 for语句
中的循环体，然后执行下面第（ 3）步。若值
为 false，则结束循环，转到第（ 5）步。
?求解表达式 3。
?转回上面第（ 2）步继续执行。
?执行 for语句下面的一个语句。
for语句的流程图
求解表达式 1
表达式 2
循 环 体
求解表达式 3
for语句的下一语句
true
false
例 求 100以内所有奇数的和
public class ForDemo {
public static void main(String[ ] args) {
int sum;
sum = 0; //计数器清 0
for(int i=1; i<=100; i+=2){
sum += i;
}
System.out.println(sum);
}
}
例 求 1+2+…+999 的和
/*试 for后分号的作用 */
public class ForDemo2{
public static void main(String[ ] args) {
int sum = 0;
int i;
for(i=1; i<1000; i++); //注意此处圆括号后面有一个分号
{
sum += i;
}
System.out.println("i=" + i);
System.out.println("sum=" + sum);
}
}
循环的嵌套
?一个循环体内又包含另一个完整的循环结构，
称为 循环的嵌套
?内嵌的循环中还可以嵌套循环，这就是 多重
循环
?上述三种循环（ while循环,do-while循环和 for
循环）语句之间可以相互嵌套使用。
例 输出一个 0~9的乘法表
public class MultiTable{
public static void main(String args[ ]){
int b,c,a;
for(b=0; b<=9; b++){
for(a=0; a<=b; a++)
System.out.print(a+"*"+b+"="+a*b+'\t');
System.out.println( );
}
}
}
循环结构中的 continue语句
? continue语句的一般语法格式为,
continue [标号 ];
? 其中，用,[ ]”括起的标号部分是可选的，分两种使用情况,
? 不带标号的使用情况,此时,continue语句用来结束本次循
环 (对于 for语句，在进行循环条件的判断之前，还要先改变
循环控制变量的值（即先执行表达式 3） )
? 带标号的使用情况,此时,continue语句跳过标号所指语句
块中所有余下部分的语句，回到标号所指语句块的条件测试
部分进行条件判断，以决定循环是否继续执行。
例 不带标号的 continue语句
class EndInnerLoop {
public static void main(String args[ ]) {
System.out.println("21世纪的闰年有,");
int n = 0; //计数
for(int year=2000; year<3000; year+=4) {
if(year%100= =0 && year%400!=0)
continue;
System.out.print(year + "\t");
n++;
if(n < 10)
continue;
System.out.println();
n=0;
}
}
}
例 带标号的 continue语句
class ContinueLabel{
public static void main(String args[ ]){
outer,
for (int i=0; i<10; i++){
for (int j=0; j<10; j++){
if (j > i){
System.out.println(" ");
continue outer;
}
System.out.print(" "+ i + "*" + j + "=" + (i*j));
}
}
}
}
打印一个三角形的 0至 9的乘法表
break语句
? 测试的条件为 true,也希望循环立即终止，这时可
以用 break语句实现此功能
? break语句与 continue语句一样，对循环的执行起限
定转向的作用
? 与 continue语句只能在循环中使用不同,break语句
除了可以用在循环语句中之外，亦可以用于 switch
语句中
? continue语句只结束本次循环，而不是终止整个循
环的执行。而 break语句则是结束整个循环语句的执
行
break语句的一般语法格式
? break语句的一般语法格式为,
break [标号 ];
? 其中，用,[ ]”括起的标号部分是可选的。分两种使用情况,
? 不带标号的情况,其功能是终止 break所在的循环，转去执
行其后的第一条语句。在执行时有两个特点：一是在有多重
循环时，它只能使循环从本层的循环跳出来；二是此时程序
一定转移到本层循环的下一个语句。
? 带标号的情况,其功能是终止由标号指出的语句块的执行，
并从紧跟该块的第一条语句处开始往下执行。典型用法是实
现从其所处的多重循环的内部直接跳出来，只要在欲跳出的
循环开始处加上标号即可。
例 不带标号的 break语句
public class BreakDemo{
public static void main(String[ ] args) {
int n = 0; //计算素数的个数
int b = 999;
outer,//外层循环，定义一个标号
do{
b+=2;
int m=(int)(Math.ceil(Math.sqrt(b)));
for(int i=2;i<=m;i++){ //内层循环，判断 b是否为素数
if(b%i= =0)
continue outer;
}
n++;
if(n= =3)
break;
}while(true);
System.out.println("大于 1000的第三个素数为," + b);
}
}
例 带标号的 break语句
public class BreakDemo {
public static void main(String[ ] args) {
int sum = 0;
coloop,//定义标号
while (sum <= 100) {
for(int count=1; count<10; count++){
sum+=count;
if (sum > 60)
break coloop;
}
}
System.out.println("sum=" + sum);
}
}
Selection Statements
?选择语句提供了一种控制机制，使得程序根
据相应的条件去执行对应的语句
?Java中的选择语句有两个,
1)负责实现两路分支的 if-else 语句
2)负责实现多路分支的 switch语句。
if-else 语句 简单形式
if-else语句的一般语法形式为,
if (布尔表达式 )
{
语句 1
}
[else
{
语句 2
}]
if语句的流程图 无 else部分
true
false
语句 1
后续语句
布尔表达式
if语句的流程图 有 else部分
布尔表达式
true
false
语句 1 语句 2
后续语句
例 没有 else部分的 if语句
class IfExam{
public static void main(String[ ] args){
System.out.println("请输入一个要求其绝对值的数,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个数！ ");
System.exit(-1);
}
double number = Double.valueOf(args[0]).doubleValue();
System.out.print("你输入的数是," + number);
if (number <= 0)
number = -number;
System.out.println(" 该数的绝对值为," + number);
}
}
例 有 else部分的 if语句
class IfTry{
public static void main(String[ ] args){
System.out.println("请输入你的成绩,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1);
}
int number = Integer.parseInt(args[0]);
if(number >= 60){
System.out.println("祝贺你,你及格了 !");
}
else{
System.out.println("真遗憾,你没及格,请继续努力 !");
}
}
}
if-else 语句 嵌套 形式
if语句中内嵌的语句 1或语句 2又是 if语句的情况称为 if 语句的嵌套,其常
用形式为,
if(布尔表达式 1)
{
语句 1
}
……
else if (布尔表达式 m)
{
语句 m
}
else
{
语句 n
}
例 实现多重嵌套
class IfSeason{
public static void main(String[ ] args){
System.out.println("请输入一个有效月份,");
if (args.length!=1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1); }
int month = Integer.parseInt(args[0]);
System.out.print("你输入的月份是," + month);
String season;
if (month= =12 || month= =1 || month= =2){
season = "冬天 ";
}else if (month= =3 || month= =4 || month= =5){
season = "春天 ";
} else{
season =,无效的月份或夏天、秋天！请重新执行。 "; }
System.out.println(" 所处季节为," + season);
}}
switch语句
?上面所讲的 if 语句的嵌套形式虽然能够实现
多路分支，满足程序流程控制的要求，但是
它欠缺灵活性，程序书写比较麻烦，而且可
读性不太好
?在 Java中，为多路选择流程控制专门提供了
一个语句 -- switch语句
?switch 语句根据一个供进行判断的表达式的
结果来执行多个操作中的一个
语法形式
switch （ 表达式 ）
{
case 常量 1,
语句 1
[break； ]
case常量 2,
语句 2
[break； ]
…
case常量 n,
语句 n
[break； ]
[default,
缺省处理语句
[break； ]
}
switch语句的流程图
常量 1
语句 1 缺省处理语句
default 常量 n
表达式
常量 2
语句 2 语句 n
break break break break
…
后续语句
switch语句的注意点
? 使用 switch 语句时，要注意用作判断的表达式必须
是符合 byte,char,short,int类型的表达式，而不能使
用浮点类型或 long类型，也不能为一个字符串；
? switch语句将表达式的值依次与每个 case子句中的
常量值相比较。如果匹配成功，则执行该 case子句
中常量值后的语句，直到遇到 break语句为止；
? case子句中常量的类型必须与表达式的类型相容，
而且每个 case子句中常量的值必须是不同的；
? default子句是可选的，当表达式的值与任一 case子
句中的值都不匹配时，就执行 default后的语句。
? （ e） break语句用来在执行完一个 case 分支后，使程序跳
出 switch 语句，执行 switch 语句的后续语句。
? （ f）在一些特殊的情况下，例如多个不同的 case值要执行
一组相同的操作，可以写成如下形式,
case常量 n,
case常量 n+1,
语句
[break； ]
? （ g） case 分支中包括多个执行语句时，可以不用花括号
,{}”括起；
? （ h）通过 if-else语句可以实现 switch 语句所有的功能。但通
常使用 switch语句更简练，且可读性强，程序的执行效率也
高；
例 用 switch语句实现判断某月份
class SwitchSeason{
public static void main(String[ ] args){
System.out.println("请输入一个有效月份,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1);
}
int month = Integer.parseInt(args[0]);
System.out.print("你输入的月份是," + month);
String season;
switch(month){
case 12,
case 1,
case 2,
season = "冬天 ";
break;
case 3,
case 4,
case 5,
season = "春天 ";
break;
case 6,
case 7,
case 8,
season = "夏天 ";
break;
case 9,
case 10,
case 11,
season = "秋天 ";
break;
default,
season = "无效的月份！请重新执行。 ";
}
System.out.println(" 所处季节为," + season);
}
}
算法设计举例
?穷举
?迭代
?递归
穷举
?穷举 是数学上最常用的方法之一，它的基本
思想是一一列举各种可能进行测试，从中找
出符合条件的解
?穷举 也称为 枚举
?计算机能够实现高速运算，借重复结构实现
穷举，比人工操作更为有效
穷举的例子
public class Test_key {
public static void main(String[ ] args) {
int x,y,z;
int max = (int)(Math.floor(Math.sqrt(300)));
//求出不大于 300的平方根的最小整数
for (x=1; x<=max; x++){
for (y=1; y<=max; y++){
if (y= =x)
continue;
z = x * x + y * y;
if (z > 300)
break;
System.out.println(x+"\t"+y+"\t"+z);
}
}
}
}
迭代
?迭代就是不断由已知值推出新值，直到求得
解为止
?一般说来迭代要由 3个环节组成,
⑴迭代初始值；
⑵迭代公式；
⑶迭代终止条件。
迭代的例子
class GreatestCommonDivisor{
public static void main(String args[ ]){ //主方法
if (args.length < 2){
System.out.println("请向应用程序传递两个参数,");
System.exit(0); }
int a=Integer.parseInt(args[0]);
int b=Integer.parseInt(args[1]); //接收命令行参数
System.out.println(a + "和 " + b + "的最大公约数为," + result(a,b));
} //主方法结束
static int result(int m,int n){ //求最大公约数的方法
int u,v,r;
u = m,v = n,r = u % v; //迭代初始值
while(r != 0){
System.out.println("u=" + u + " v=" + v + " r=" + r);
u = v,v = r,r = u % v; //迭代公式
}
return v; //返回结果
}
}
递归
?递归的基本思想
?在求解一个问题时，将这个问题递退简化为
一个规模较小的同一问题，并设法求得这个
规模较小的问题的解，在此基础上再递进求
解原来的问题
?如果经递退简化的问题还难以求解，可以再
进行递退简化，直至将问题递退简化到一个
容易求解的基本问题为止
设计递归程序时步骤
?设计递归程序时一般分两个步骤,
?一个步骤是求得范围缩小的同性质问题的结
果
?另一个步骤是利用这个已得到的结果和一个
简单的操作来求得问题的最后解答
递归的例子
public class CountE{
static double fact(int n) //定义计算 n！的方法
{
if( n= =1)
return 1; //递归头
else
return n * (fact(n-1)); //递归调用自身
}
public static void main (String args[ ]) //主方法
{
double e = 1;
int i = 1;
do{
double x = 1 / fact(i);
if (x >= 0.0000001){
e = e + x;
System.out.println("i=" + i + " e=" + e);
i++;
}
else
break;
}while(true);
System.out.print("This is result:");
System.out.println("e=" + e);
}
}
习题
类由类的首部和类体构成，而类体又由类的成员变量和
成员方法构成。方法是对客体行为的描述
第 2章 方法设计
?方法的基本概念
?运算符与表达式
?流程控制语句
?算法设计举例
方法的基本概念
?Java类由状态（或属性）和行为两部分组成。
?属性是保存描述类对象状态数据的途径，但
属性并不具备任何活动能力。一个类要真正
能完成一定的操作，就必须为类创建行为。
?行为描述了该类需要完成的每项具体任务所
用的不同程序段，每个这样的就叫做“方法”
方法分类
?在 Java程序中，用“数据”来描述类的属性，
用“方法”来实现类的行为。
?方法可分为成员方法（ instance method）和
类方法（ class method，即由 static修饰的方
法，又叫做静态方法）两种
方法的声明
?描述方法的处理过程及其所需的参数，并用
一个方法名来标识这个处理过程
?方法定义中的参数并没有实际值，仅仅是为
了描述处理过程而引入的，因此称为 形式参
数 （简称 形参 ）
方法的使用
?通过向客体发送消息执行方法所定义的处理
功能。使用方法时给出参数的实际值，这些
实际值称为 实际参数 （简称 实参 ）
方法首部的声明
? 语法形式如下,
? [方法修饰符 ] 方法返回值类型 方法名 （ [形式参数表 ]）
? 其中,
? 方法修饰符 可以是 static,final以及 public,private和
protected等。 static,final本书不作专门介绍，“方法修饰
符”是可选的语法部分。
? 方法返回值类型 说明方法返回值的数据类型，可是 Java基本
数据类型，也可是复合数据类型。 当无返回值时，其返回值
类型须说明为 void。
? 方法名 标识所声明的方法，必须是合法的 Java标识符；
? 形式参数表 说明方法所需要的参数，当方法有多个参数时，
参数间需用逗号“，”隔开；当方法没有参数时，可以没有
“形式参数表”部分。形式参数的作用域是整个方法体。
方法体
?方法体是一个语句序列，这一语句序列具体
描述方法的返回值、方法的参数和方法所在
类的成员变量之间的关系，以实现方法的功
能。
?方法体中可以定义其内部使用的局部变量，
其作用域是整个方法体。
方法的返回值
?若方法的返回值类型不是 void时，方法体中
必须用 return语句来返回一个方法声明时指定
类型的值。
?return 语句的语法形式为,
return [表达式 ] ；
?其中,return是关键字。
方法声明的例子
? 方法 setCNumber,
? void setCNumber (int xNumber)
// 方法首部声明：无方法修饰符，方法名为
//setCNumber，方法的参数为 xNumber，这一方法
//无返回值
? { //方法体开始
? cNumber = xNumber;
//方法体中的语句，描述方法的功能
? } //方法体结束
方法 getCNumber
? int getCNumber( )
//方法首部声明：无方法修饰符，方法名为
//getCNumber，这一方法无参数，这一方法
//的返回值类型为 int
? { //方法体开始
? return cNumber;
? //将 cNumber的值作为 getCNumber方法的返回值
? } //方法体结束
方法的调用与参数传递
?调用对象成员方法的语法形式为,
对象名, 成员方法名 （ [实际参数表 ]）；
?对象名 指定所使用的对象；
?成员方法名 指定所要调用的成员方法；
?实际参数表 是 0个或多个表达式构成，多个表
达式之间用逗号“，”分隔。实际参数的个
数、顺序及类型应与被调用方法的形式参数
表中的形式参数一致。
调用对象成员方法的语义
?计算实际参数表中（各）表达式的值，并将
它（们）一一传送给被调用方法中对应的形
式参数，执行被调用方法的方法体。
?方法调用的结果就是被调用方法的执行结果
实现两 float型数相加的方法例子
class MethodDemo1{
float add(float x,float y)
//建议所取的方法名有助于说明方法的功能，以便阅读程序和记忆
{
float z;
// z是方法体的局部变量，作用域是整个 add方法的方法体
z = x + y;
return z;
}
}
class TryMethodDemo1{ //主类
public static void main(String args[ ]){
MethodDemo1 a = new MethodDemo1( );
System.out.println(a.add(5,8));
}
}
实现两 float型数相加的方法例子二
class ObjPara { //定义对象作为参数的类，为便于举例，本方法只有一个成员变量
float temp;
}
class MethodDemo2{
void add(float x,float y,ObjPara z){ //方法首部声明，此方法没有返回值 。
z.temp = x + y; //将 x+y的结果存入类变量 z的成员变量 temp中 。
}
}
class TryMethodDemo2{ //主类
public static void main(String args[ ]){
ObjPara b = new ObjPara( );
MethodDemo2 a = new MethodDemo2( );
a.add(4,6,b);
System.out.println(b.temp);
}
}
演示方法之间的消息发送与参数传递
class MethodDemo3{
float add(float x,float y){
float z;
z = x + y;
return z; }
void callAdd(float m,float n){
float t;
t = add(m,n);
/*向方法 add发消息，将参数 m,n的值分别传递给 x,y，然后执行
方法 add的方法体，计算 x+y，计算结果作为 add的返回值传回给 t*/
System.out.print(m+"+"+n+"="+t); }
}
class TryMethodDemo3{ //主类
public static void main(String args[ ]){
MethodDemo3 a=new MethodDemo3( );
a.callAdd(4,6); }
}
方法间的消息发送与参数传递演示 二
class ObjPara{
float temp;}
class MethodDemo4{
void add(float x,float y,ObjPara z){
z.temp = x + y; }
void callAdd(float m,float n){
ObjPara k = new ObjPara();
add(m,n,k);
/*向方法 add发消息，将参数 m,n的值分别传递给 x,y,并将 k的存储地址值传送给 z，
然后执行方法 Add的方法体，计算 x+y，计算结果通过对象 k的成员 temp传回 */
System.out.print(m+"+"+n+"="+k.temp);
} // k.temp的值即为 m+n
}
class TryMethodDemo4{ //主类
public static void main(String args[ ]){
MethodDemo4 a = new MethodDemo4( );
a.callAdd(4,6); }
}
2.2 运算符与表达式
?1 赋值运算
?2 算术运算
?3 关系运算
?4 逻辑运算
?5 位运算符
?6 三元运算
?7 其它运算符
基本定义
?对数据进行的操作称为 运算
?表示各种不同运算的符号称为 运算符
?参于运算的数据称为 操作数（ operand）
?表达式（ Expression） 是由操作数和运算符
按一定的语法形式组成的符号序列
?通过算术运算符将运算对象连接起来的式子，
就称为 算术表达式
Java语言的运算符
分类 运算符 结合性
一元运算符 + － ++ - - ！ ~ ( ) * 右
算术运算符 * / % 左 + －
移位运算符 << >> >>> 左
比较运算符 < <= > >= instanceof 左 = = !=
按位运算符
&
左 ^
|
短路运算符 && 左 | |
条件（三元）运算符?, 右
赋值运算符 =,op=”（复合赋值运算符） 右
1 赋值运算
?给新定义的变量进行初始化或修改变量的内
容需要用到赋值运算。
?赋值运算的一般形式为,
变量 = 表达式 ;
复合赋值运算符
?在赋值运算符,=”之前加上其它运算符 <op>，
就构成了 复合赋值运算符, <op>=”
?复合赋值运算符,<op>=”集成了计算和赋值
两大功能，对于任何类型兼容的表达式 x和 y
来说,x <op>= y
?复合赋值运算符包括,*=,/=,%=,+=、－
=,<<=,>>=,>>>=,&=,^=和 |=
2 算术运算
?算术运算符作用于整型或浮点型数据，完成
算术运算。
?按操作数个数来分，有 一元算术运算符 和 二
元算术运算符
一元算术运算符
运算符 用 法 描 述
+ +op 正值
- -op 负值
++ ++op或 op++ 加 1
- - - -op或 op- - 减 1
++和 - -算术运算符
?称为增一运算符和减一运算符
?可以作为前缀运算符
?可以作为后缀运算符
++和 --运算符及用法
运算符 用法 描 述
++ x++ 表达式 x++的值为 x，然后 x的值增 1
++ ++x 表达式 ++x的值为 x+1,x的值增 1
-- x-- 表达式 x--的值为 x，然后 x的值减 1
-- --x 表达式 --x的值为 x-1,x的值减 1
二元算术运算符
运算符 用 法 描 述
+ op1 +op2 操作数 op1加上 op2
- op1-op2 操作数 op1减去 op2
* op1 * op2 操作数 op1乘以 op2
/ op1 / op2 操作数 op1除以 op2
% op1 % op2 求操作数 op1除以 op2的余数（取模）
?整数算术运算的除法和取模遵循以下等式
（ a/b） *b+（ a%b） = =a
?对于浮点算术运算来说
a%b和 a-（（ int）（ a/b） *b）的语义相同
?在取模运算时，假设操作数中至少有一个负
数，那么一般采取这样一个有用的规则
先忽略掉所有操作数的符号来计算得到结果，
然后将,%”左边的操作符的符号赋给它得到
最终答案
一个算术运算的例子
public class ArithmaticOp{
public static void main( String args[ ] ){
int a = 5,b = 3;
int c = ++a / b;
int c2 = a-- / b;
int c3 = a * 2 % b;
double d = 2.5;
double d2 = d % 3;
System.out.println("c=" + c);
System.out.println("c2=" + c2);
System.out.println("c3=" + c3);
System.out.println("d2=" + d2);
}
}
3 关系运算
?关系运算实际上就是比较运算，它的运算结
果是一个布尔类型的值。
?如果两个运算对象符合关系运算符所要求的
比较关系，则关系运算结果为 true，否则为
false。
?Java语言提供的关系运算符都是二元运算符
关系运算符
运算符 用 法 功 能
> op1 > 0p2 如果 op1大于 op2则结果为 true，否则为 false
>= op1 >= op2 如果 op1大于或等于 op2则结果为 true，否则为 false
< op1 < op2 如果 op1小于 op2则结果为 true，否则为 false
<= op1 <= op2 如果 op1小于或等于 op2则结果为 true，否则为 false
= = op1 = = op2 如果 op1等于 op2则结果为 true，否则为 false
!= op1 != op2 如果 op1不等于 op2则结果为 true，否则为 false
关系表达式
?用关系运算符将两个相同类型的表达式连接
起来的的式子，称为 关系表达式
3>5
?a?<?z?
x+y!=z
?都是合法的关系表达式
赋值（,=”）和等价比较（,= =”）
? 关系运算符 (<,<=,>,>=)一般适用于两侧的操作
数均为整数型、浮点型或字符型数据的情形，布尔
型数据只能用在 = =或 !=比较中。
? 关系运算符 (<,<=,>,>=)连接的表达式本身不能
是关系表达式。例如,x>y>z是非法的。
? 关系运算的结果不能存放在一个非布尔型变量中
一个关系运算的例子
public class RelationOp
{
public static void main( String args[ ] )
{
int a=25,b=3;
boolean d = a > b;
boolean d1=3.5 < 2.6;
boolean d2='A' <= 'A';
boolean d3 = false != true;
boolean e = a >= a * 2 - b * 9;
System.out.println("d= "+ d);
System.out.println("d1= "+ d1);
System.out.println("d2= "+ d2);
System.out.println("d3= "+ d3);
System.out.println("e= "+ e);
}
}
4 逻辑运算
?关系运算 只能表示一个简单的条件，而 逻辑
运算 可以将几个关系表达式或者布尔值连接
起来，表示一个较复杂的条件
?逻辑运算 的运算对象必须是布尔值类型的表
达式，运算结果也是布尔值类型的数据
逻辑运算符
运算符 用 法 功 能 分类
!（逻辑非） !op1 op1为 true，则结果为 false，否则为true。 一元
&&（逻辑与） op1 && op2 op1和 op2都为 true，则结果为 true，否则为 false。
二元
||（逻辑或） op1 || op2 op1和 op2都为 false，则结果为 false，否则为 true。
逻辑运算的真值表
x y !x !y x && y x || y
true true false false true true
true false false true false true
false true true false false true
false false true true false false
短路运算符
?,&&”和,||“又叫做 短路运算符
? 在由它们连接组成的逻辑表达式的求解过程中，总
是先求出运算符左边的表达式的值，再根据具体情
况决定是否需要计算运算符右边的表达式
? 对,||”运算，如果左边的表达式的值为 true，则不
必对运算符右边的表达式再进行运算，整个表达式
的结果就为 true
? 对,&&”运算，如果左边的表达式的值为 false，则
不必对运算符右边的表达式再进行运算，整个表达
式的结果就为 false。
关系运算符和逻辑运算符共用的例子
public class RelationAndConditionOp{
public static void main(String args[ ]){
int a = 28,b = 3;
int e = 3;
if(e != 0 && a/e>5)
System.out.println("a/e="+a/e);
int f=0;
//下面不会发生除零溢出的错误，因为 e!=0为 false，所以不需要对 a/f进行运算。
if(f!=0 && a/f>5)
System.out.println("a/f="+a/f);
else
System.out.println("f="+f);
}
}
5 位运算符
?位运算符用来对二进制位进行操作，其操作
数只能为整型或字符型数
?提示：在 Java中，使用补码来表示二进制数，
最高位为符号位，正数的符号位为 0，负数的
符号位为 1
位运算符
运算符 用 法 描 述 分类
~ ~ op1 按位取反运算
按位运算符
一元
& op1& 0p2 按位与运算
二元
| op1| 0p2 按位或运算
^ op1^ 0p2 按位异或运算
<< op1<< 0p2 左移运算
移位运算符 >> op1>> 0p2 带符号右移运算
>>> op1>>> 0p2 不带符号右移运算
4种按位运算
?“~”是按位取反运算符
?,&”是按位与运算符
?,|”是按位或运算符
?,^”是按位异或运算符
按位取反运算符
?对数据的每个二进制位取反，即把 1变成 0，
把 0变成 1。
?例如,
~00001111=11110000
“&”是按位与运算符
?要求有两个操作数进行运算。如果两个相应
位均为 1，则该位的结果为 1，否则结果为 0。
即,
0&0=0 0&1=0
1&0=0 1&1=1
?提示,
对某个数中某些特定的位清零
用来取某个数中某些指定的位
“|”是按位或运算符
?只要两个相应位中有一个为 1，则该位的结果
为 1，否则结果为 0。即,
0|0=0 0|1=1
1|0=1 1|1=1
?提示,
按位或运算可以用来将某个数中某
些特定的位置 1
“^”是按位异或运算符
?同样要求有两个操作数进行运算。如果两个
相应位相同，则该位的结果为 0，否则结果为
1。即,
0^0=0 0^1=1
1^0=1 1^1=0
?提示,
用来使某个数中某些特定的位取反
实现两个值的交换，而不需使用临时变量
布尔型操作数上时的运算规则
Op1 Op2 Op1& Op2 Op1| Op2 Op1^ Op2
true true true true false
true false false true true
false true false true true
false false false false false
其它 3种移位运算
?（ a）左移运算 (<<)
?（ b）带符号右移运算 (>>，又称为算术右移 )
?（ c）不带符号的右移运算 (>>>，又称为逻辑
右移 )
移位运算的例子
x（十进制表示） x的二进制补码表示 x<<2 x>>2 x>>>2
30 00011110 01111000 00000111 00000111
-17 11101111 10111100 11111011 00111011
6 三元运算
?条件运算符,?:”比较特殊，是 Java语言中仅
有的一个三元运算符，它的一般形式为,
表达式 1? 表达式 2,表达式 3
?其中表达式 e1的值必须是布尔值类型，如果
该值为 true，则对表达式 e2进行求值，并将
e2的求值结果作为整个表达式的值；否则对
表达式 e3进行求值并将 e3的结果作为整个表
达式的值。
一个条件运算符的例子
/*编程从三个整数 x,y,z中选出最大和最小者。 */
class Max2{
public static void main(String args[ ]){
int x = 335;
int y = 212;
int z = 38;
int a,b,max,min;
System.out.println(" 原来的整数的值为,x="+x+",y="+y+",z="+z);
a = (x > y? x, y);
max = (a > z? a, z);
b = (x < y? x, y);
min = ( b < z? b, z);
System.out.println(" 最大的元素的值为," + max);
System.out.println(" 最小的元素的值为," + min);
}
}
7 其它运算符
?这里主要介绍对象运算符 instanceof
?它也可以说是一种比较运算符，用来判断一
个运行时的对象是否属于某个指定类或其子
类的实例，如果是则返回 true，否则返回
false
?其一般形式为,
对象名 instanceof 类名
对象运算符的用法
public void method (Employee e) {
if ( e instanceof Manager ) {
… //do something as a Manager
}
else if ( e instanceof Contractor ) {
… //do something as a Contractor
}
else {
… //do something else
}
}
2.3 流程控制语句
语句类型 关键字
循环 while,do-while,for
选择 if-else,switch-case
转向控制 break,continue,label:,return
*异常处理 try-catch-finally,throw
重点说明流程控制语句
?1 循环结构（ Loop Constructs）
?2 选择语句（ Selection Statements）
Loop Constructs
?循环的作用是反复执行同一块代码直到满足
结束条件
?三种循环语句,
1） while 语句
2） do-while语句
3） for语句
while 语句
?while 语句实现“当型”循环，它的语法形式
为,
while (布尔表达式 )
循环体
while 语句用于在布尔表达式（即测试条件）的值保持为真（ true）时反复地执
行其中的内嵌语句（一般叫做循环体）
while 语句的流程图
循 环 体
布尔表达式
true
例 求 100以内所有奇数的和
public class WhileDemo {
public static void main(String[ ] args) {
int i,sum;
sum = 0; //计数器清 0
i = 1; //i的初始值为 1（因为 1是最小的奇数）
while (i <= 100){
sum += i;
i += 2; //奇数的间隔为 2
}
System.out.println(sum);
}
}
do-while语句
?do-while 语句实现“直到型”循环，它的语
法形式如下,
do
循环体
while (布尔表达式 );
do-while 语句执行的过程为：先执行一次循环体中的语句，然后测试布
尔表达式的值。如布尔表达式的值为真，那就返回执行循环体中的内容
do-while 语句的流程图
布尔表达式
循 环 体
false
true
例 求 100以内所有奇数的和
public class DoWhileDemo {
public static void main(String[ ] args) {
int i,sum;
sum = 0; //计数器清 0
i = 1; //i的初始值为 1
do{
sum += i;
i += 2;
}while (i<=100);
System.out.println("sum=" + sum);
}
}
do-while 语句和 while语句的不同之处
?do-while 语句总是先进入循环，然后检测条
件，再决定是否继续循环
?while 语句是先测试条件，再决定是否进入循
环
?所以，用 do-while 语句时，循环体至少执行
一次。
体会 while 语句
public class WhileDemo2{
public static void main(String[ ] args){
int i = 88;
while ( i < 88){
System.out.println("Print " + i);
i++;
}
}
}
此例的运行结果是什么也不输出
体会 do-while语句
public class DoWhileDemo2{
public static void main(String[ ] args){
int i = 88;
do{
System.out.println("Print " + i);
i++;
}while (i < 88);
}
}
此例的运行结果是,Print 88
for语句
?实现“当型”循环，它的语法形式为,
for (表达式 1； 表达式 2； 表达式 3)
循环体
每个 for语句都有一个用于决定循环开始和结束的变量，通常
称这个变量为 循环控制变量
for 语句的执行过程
?先求解表达式 1；
?求解表达式 2，若其值为 true，则执行 for语句
中的循环体，然后执行下面第（ 3）步。若值
为 false，则结束循环，转到第（ 5）步。
?求解表达式 3。
?转回上面第（ 2）步继续执行。
?执行 for语句下面的一个语句。
for语句的流程图
求解表达式 1
表达式 2
循 环 体
求解表达式 3
for语句的下一语句
true
false
例 求 100以内所有奇数的和
public class ForDemo {
public static void main(String[ ] args) {
int sum;
sum = 0; //计数器清 0
for(int i=1; i<=100; i+=2){
sum += i;
}
System.out.println(sum);
}
}
例 求 1+2+…+999 的和
/*试 for后分号的作用 */
public class ForDemo2{
public static void main(String[ ] args) {
int sum = 0;
int i;
for(i=1; i<1000; i++); //注意此处圆括号后面有一个分号
{
sum += i;
}
System.out.println("i=" + i);
System.out.println("sum=" + sum);
}
}
循环的嵌套
?一个循环体内又包含另一个完整的循环结构，
称为 循环的嵌套
?内嵌的循环中还可以嵌套循环，这就是 多重
循环
?上述三种循环（ while循环,do-while循环和 for
循环）语句之间可以相互嵌套使用。
例 输出一个 0~9的乘法表
public class MultiTable{
public static void main(String args[ ]){
int b,c,a;
for(b=0; b<=9; b++){
for(a=0; a<=b; a++)
System.out.print(a+"*"+b+"="+a*b+'\t');
System.out.println( );
}
}
}
循环结构中的 continue语句
? continue语句的一般语法格式为,
continue [标号 ];
? 其中，用,[ ]”括起的标号部分是可选的，分两种使用情况,
? 不带标号的使用情况,此时,continue语句用来结束本次循
环 (对于 for语句，在进行循环条件的判断之前，还要先改变
循环控制变量的值（即先执行表达式 3） )
? 带标号的使用情况,此时,continue语句跳过标号所指语句
块中所有余下部分的语句，回到标号所指语句块的条件测试
部分进行条件判断，以决定循环是否继续执行。
例 不带标号的 continue语句
class EndInnerLoop {
public static void main(String args[ ]) {
System.out.println("21世纪的闰年有,");
int n = 0; //计数
for(int year=2000; year<3000; year+=4) {
if(year%100= =0 && year%400!=0)
continue;
System.out.print(year + "\t");
n++;
if(n < 10)
continue;
System.out.println();
n=0;
}
}
}
例 带标号的 continue语句
class ContinueLabel{
public static void main(String args[ ]){
outer,
for (int i=0; i<10; i++){
for (int j=0; j<10; j++){
if (j > i){
System.out.println(" ");
continue outer;
}
System.out.print(" "+ i + "*" + j + "=" + (i*j));
}
}
}
}
打印一个三角形的 0至 9的乘法表
break语句
? 测试的条件为 true,也希望循环立即终止，这时可
以用 break语句实现此功能
? break语句与 continue语句一样，对循环的执行起限
定转向的作用
? 与 continue语句只能在循环中使用不同,break语句
除了可以用在循环语句中之外，亦可以用于 switch
语句中
? continue语句只结束本次循环，而不是终止整个循
环的执行。而 break语句则是结束整个循环语句的执
行
break语句的一般语法格式
? break语句的一般语法格式为,
break [标号 ];
? 其中，用,[ ]”括起的标号部分是可选的。分两种使用情况,
? 不带标号的情况,其功能是终止 break所在的循环，转去执
行其后的第一条语句。在执行时有两个特点：一是在有多重
循环时，它只能使循环从本层的循环跳出来；二是此时程序
一定转移到本层循环的下一个语句。
? 带标号的情况,其功能是终止由标号指出的语句块的执行，
并从紧跟该块的第一条语句处开始往下执行。典型用法是实
现从其所处的多重循环的内部直接跳出来，只要在欲跳出的
循环开始处加上标号即可。
例 不带标号的 break语句
public class BreakDemo{
public static void main(String[ ] args) {
int n = 0; //计算素数的个数
int b = 999;
outer,//外层循环，定义一个标号
do{
b+=2;
int m=(int)(Math.ceil(Math.sqrt(b)));
for(int i=2;i<=m;i++){ //内层循环，判断 b是否为素数
if(b%i= =0)
continue outer;
}
n++;
if(n= =3)
break;
}while(true);
System.out.println("大于 1000的第三个素数为," + b);
}
}
例 带标号的 break语句
public class BreakDemo {
public static void main(String[ ] args) {
int sum = 0;
coloop,//定义标号
while (sum <= 100) {
for(int count=1; count<10; count++){
sum+=count;
if (sum > 60)
break coloop;
}
}
System.out.println("sum=" + sum);
}
}
Selection Statements
?选择语句提供了一种控制机制，使得程序根
据相应的条件去执行对应的语句
?Java中的选择语句有两个,
1)负责实现两路分支的 if-else 语句
2)负责实现多路分支的 switch语句。
if-else 语句 简单形式
if-else语句的一般语法形式为,
if (布尔表达式 )
{
语句 1
}
[else
{
语句 2
}]
if语句的流程图 无 else部分
true
false
语句 1
后续语句
布尔表达式
if语句的流程图 有 else部分
布尔表达式
true
false
语句 1 语句 2
后续语句
例 没有 else部分的 if语句
class IfExam{
public static void main(String[ ] args){
System.out.println("请输入一个要求其绝对值的数,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个数！ ");
System.exit(-1);
}
double number = Double.valueOf(args[0]).doubleValue();
System.out.print("你输入的数是," + number);
if (number <= 0)
number = -number;
System.out.println(" 该数的绝对值为," + number);
}
}
例 有 else部分的 if语句
class IfTry{
public static void main(String[ ] args){
System.out.println("请输入你的成绩,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1);
}
int number = Integer.parseInt(args[0]);
if(number >= 60){
System.out.println("祝贺你,你及格了 !");
}
else{
System.out.println("真遗憾,你没及格,请继续努力 !");
}
}
}
if-else 语句 嵌套 形式
if语句中内嵌的语句 1或语句 2又是 if语句的情况称为 if 语句的嵌套,其常
用形式为,
if(布尔表达式 1)
{
语句 1
}
……
else if (布尔表达式 m)
{
语句 m
}
else
{
语句 n
}
例 实现多重嵌套
class IfSeason{
public static void main(String[ ] args){
System.out.println("请输入一个有效月份,");
if (args.length!=1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1); }
int month = Integer.parseInt(args[0]);
System.out.print("你输入的月份是," + month);
String season;
if (month= =12 || month= =1 || month= =2){
season = "冬天 ";
}else if (month= =3 || month= =4 || month= =5){
season = "春天 ";
} else{
season =,无效的月份或夏天、秋天！请重新执行。 "; }
System.out.println(" 所处季节为," + season);
}}
switch语句
?上面所讲的 if 语句的嵌套形式虽然能够实现
多路分支，满足程序流程控制的要求，但是
它欠缺灵活性，程序书写比较麻烦，而且可
读性不太好
?在 Java中，为多路选择流程控制专门提供了
一个语句 -- switch语句
?switch 语句根据一个供进行判断的表达式的
结果来执行多个操作中的一个
语法形式
switch （ 表达式 ）
{
case 常量 1,
语句 1
[break； ]
case常量 2,
语句 2
[break； ]
…
case常量 n,
语句 n
[break； ]
[default,
缺省处理语句
[break； ]
}
switch语句的流程图
常量 1
语句 1 缺省处理语句
default 常量 n
表达式
常量 2
语句 2 语句 n
break break break break
…
后续语句
switch语句的注意点
? 使用 switch 语句时，要注意用作判断的表达式必须
是符合 byte,char,short,int类型的表达式，而不能使
用浮点类型或 long类型，也不能为一个字符串；
? switch语句将表达式的值依次与每个 case子句中的
常量值相比较。如果匹配成功，则执行该 case子句
中常量值后的语句，直到遇到 break语句为止；
? case子句中常量的类型必须与表达式的类型相容，
而且每个 case子句中常量的值必须是不同的；
? default子句是可选的，当表达式的值与任一 case子
句中的值都不匹配时，就执行 default后的语句。
? （ e） break语句用来在执行完一个 case 分支后，使程序跳
出 switch 语句，执行 switch 语句的后续语句。
? （ f）在一些特殊的情况下，例如多个不同的 case值要执行
一组相同的操作，可以写成如下形式,
case常量 n,
case常量 n+1,
语句
[break； ]
? （ g） case 分支中包括多个执行语句时，可以不用花括号
,{}”括起；
? （ h）通过 if-else语句可以实现 switch 语句所有的功能。但通
常使用 switch语句更简练，且可读性强，程序的执行效率也
高；
例 用 switch语句实现判断某月份
class SwitchSeason{
public static void main(String[ ] args){
System.out.println("请输入一个有效月份,");
if (args.length != 1){
System.err.println("请重新执行，一定要输入一个整数！ ");
System.exit(-1);
}
int month = Integer.parseInt(args[0]);
System.out.print("你输入的月份是," + month);
String season;
switch(month){
case 12,
case 1,
case 2,
season = "冬天 ";
break;
case 3,
case 4,
case 5,
season = "春天 ";
break;
case 6,
case 7,
case 8,
season = "夏天 ";
break;
case 9,
case 10,
case 11,
season = "秋天 ";
break;
default,
season = "无效的月份！请重新执行。 ";
}
System.out.println(" 所处季节为," + season);
}
}
算法设计举例
?穷举
?迭代
?递归
穷举
?穷举 是数学上最常用的方法之一，它的基本
思想是一一列举各种可能进行测试，从中找
出符合条件的解
?穷举 也称为 枚举
?计算机能够实现高速运算，借重复结构实现
穷举，比人工操作更为有效
穷举的例子
public class Test_key {
public static void main(String[ ] args) {
int x,y,z;
int max = (int)(Math.floor(Math.sqrt(300)));
//求出不大于 300的平方根的最小整数
for (x=1; x<=max; x++){
for (y=1; y<=max; y++){
if (y= =x)
continue;
z = x * x + y * y;
if (z > 300)
break;
System.out.println(x+"\t"+y+"\t"+z);
}
}
}
}
迭代
?迭代就是不断由已知值推出新值，直到求得
解为止
?一般说来迭代要由 3个环节组成,
⑴迭代初始值；
⑵迭代公式；
⑶迭代终止条件。
迭代的例子
class GreatestCommonDivisor{
public static void main(String args[ ]){ //主方法
if (args.length < 2){
System.out.println("请向应用程序传递两个参数,");
System.exit(0); }
int a=Integer.parseInt(args[0]);
int b=Integer.parseInt(args[1]); //接收命令行参数
System.out.println(a + "和 " + b + "的最大公约数为," + result(a,b));
} //主方法结束
static int result(int m,int n){ //求最大公约数的方法
int u,v,r;
u = m,v = n,r = u % v; //迭代初始值
while(r != 0){
System.out.println("u=" + u + " v=" + v + " r=" + r);
u = v,v = r,r = u % v; //迭代公式
}
return v; //返回结果
}
}
递归
?递归的基本思想
?在求解一个问题时，将这个问题递退简化为
一个规模较小的同一问题，并设法求得这个
规模较小的问题的解，在此基础上再递进求
解原来的问题
?如果经递退简化的问题还难以求解，可以再
进行递退简化，直至将问题递退简化到一个
容易求解的基本问题为止
设计递归程序时步骤
?设计递归程序时一般分两个步骤,
?一个步骤是求得范围缩小的同性质问题的结
果
?另一个步骤是利用这个已得到的结果和一个
简单的操作来求得问题的最后解答
递归的例子
public class CountE{
static double fact(int n) //定义计算 n！的方法
{
if( n= =1)
return 1; //递归头
else
return n * (fact(n-1)); //递归调用自身
}
public static void main (String args[ ]) //主方法
{
double e = 1;
int i = 1;
do{
double x = 1 / fact(i);
if (x >= 0.0000001){
e = e + x;
System.out.println("i=" + i + " e=" + e);
i++;
}
else
break;
}while(true);
System.out.print("This is result:");
System.out.println("e=" + e);
}
}
习题
