- 一、三种算法基本结构
- 二、布尔类型及其运算
- 1、关系运算符
- 2、逻辑运算符
- 三、选择语句
- 1、Java语法：if-else语句
- 例1 实现求倒数算法的Java程序（if-else语句）
- 例2 判断年份是否闰年的Java程序
- 例3 求符号函数sgn(x)的Java程序
- 2、Java语法：if-else if语句
- 例4 求符号函数sgn(x)的Java程序（if-else if语句）
- 例5 显示星期几英文单词的Java程序
- 3、Java语法：条件运算符“? :”
- 4、Java语法：switch-case语句
- 例6 显示星期几英文单词的Java程序（switch-case语句）
- 例7 显示不同月份天数的Java程序（switch-case语句：共用语句）
- 四、循环语句
- 1、Java语法：while语句
- 例8 求解奇数数列前N项累加和的Java程序（while语句）
- 2、Java语法：do-while语句
- 例9 求解奇数数列前N项累加和的Java程序（do-while语句）
- 3、Java语法：for语句
- 例10 求解奇数数列前N项累加和的Java程序（for语句）
- 五、break语句和continue语句
- 1、break语句
- 例11 一个计算圆面积的Java程序（break语句应用示例）
- 2、多重循环
- 例12 生成乘法表的Java程序 （多重循环应用示例）
- 3、continue语句
- 例13 显示1~50之间所有能被3整除的数（continue语句应用示例）
- 例14 显示100~200之间的所有质数（带标号的continue语句应用示例）
- 顺序结构、选择结构、循环结构
- 条件：真（true）、假（false）
- 布尔类型（boolean）
- 关系运算符：例如，大于、小于、等于
- 逻辑运算符：与、或、非
- Java语言：选择语句和循环语句
–布尔类型：boolean、true、false
–关系运算符：用于比较两个数之间的大小
| >（大于） | >=（大于等于） | <（小于） | <=（小于等于） | ==（等于） | !=（不等于） |
|---|
| 关系表达式 | 布尔型结果 | 备注 |
|---|---|---|
| 5 > 3 | true | 5大于3吗？是的 |
| 5 >= 3 | true | 5大于或等于3吗？是的 |
| 5 <= 3 | false | 5小于或等于3吗？不是 |
| 5 == 3 | false | 5等于3吗？不是 |
| 5 != 3 | true | 5不等于3吗？是的 |
| 2+3 <= 1+2 | false | 比较两个算术表达式时，先计算表达式，再比较其结果。算术运算符优先级高于关系运算符。 |
由关系表达式所描述的条件举例（假设：int x = 10;）
| 条件 | 布尔型结果 | 条件是否成立 |
|---|---|---|
| x > 5 | true | x大于5吗？是的，条件成立 |
| x < 5 | false | x小于5吗？不是，条件不成立 |
| x - 5 == 5 | true | x – 5等于5吗？是的，条件成立 |
| x - 5 < 0 | false | x – 5小于0吗？不是，条件不成立 |
| 逻辑运算符 | 运算规则 |
|---|---|
| &&（逻辑与） | 双目运算符。若两个操作数都为true，则结果为true；否则为false。相当于“并且”的意思。 |
| || （逻辑或） | 双目运算符。若两个操作数中有一个为true，则结果为true；否则为false。相当于“或”的意思。 |
| ! （逻辑非） | 单目运算符。若操作数为true则结果为false；若操作数为false则结果为true。相当于“求反”的意思。 |
由逻辑表达式所描述的复合条件举例（假设：int x=10, y=20;）
| 复合条件 | 布尔型结果 | 复合条件是否成立 |
|---|---|---|
| x > 5 && y > 10 | true | 条件成立 |
| x < 5 || y < 10 | false | 条件不成立 |
| x - 5 == 5 || y == 0 | true | 条件成立 |
| !(x > 5) | false | 条件不成立 |
有些算法，其中的某些操作步骤需满足特定条件才被执行
算法举例：给定x的值，求其倒数
定义变量x，申请保存数值的内存空间。 从键盘输入变量x的值。 如果条件“x不等于0”成立，则转到4计算倒数，否则转到5提示错误信息。 计算并显示表达式1/x的结果，转6。 条件“x不等于0”不成立（即x等于0），显示错误信息。 算法结束
–如果……，就……，否则……
–如果条件成立，则执行算法分支1，否则执行算法分支2
–选择语句：if-else、switch-case
1、Java语法：if-else语句Java语法：if-else语句
if (表达式)
{ 语句1 }
else
{ 语句2 }
语法说明：
- 表达式指定一个判断条件。该表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
- 语句1是描述算法分支1的Java语句序列，即条件成立时执行的语句序列。
- 语句2是描述算法分支2的Java语句序列，即条件不成立时执行的语句序列。如果条件不成立时不需要做什么处理，则省略else和{语句2}。
- 语句1、语句2可能是包含多条Java语句的序列，此时必须用一对大括号{ }将它们括起来。如果只包含一条语句，则大括号可以省略。
- 计算机执行该语句时，首先计算表达式（即判断条件），若结果为true（条件成立），则执行语句1；否则，执行else后面的语句2。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
double x; // 定义一个double型变量x
x = sc.nextDouble(); // 键盘输入变量x的值
if (x != 0) { // 判断条件“x不等于0”是否成立
// 条件成立时执行下列代码。因为是多条语句，所以用{ }括起来
double y; // 再定义一个double型变量y，用于保存x的倒数
y = 1 / x; // 求x的倒数，结果赋值给y
System.out.println( y ); // 显示y的值，即x的倒数
}
else
System.out.println( "0的倒数没有意义" ); // 显示错误信息
// else分支只有一条语句，可省略大括号
}
}
例2 判断年份是否闰年的Java程序
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int year; // 定义一个int型变量year
year = sc.nextInt(); // 键盘输入一个年份，保存到变量year中
if ( (year%4 == 0 && year%100 != 0) || year%400 == 0 ) // 判断闰年条件是否成立
System.out.println( year + "是闰年" ); // 条件成立则该年份是闰年
else
System.out.println( year + "不是闰年" ); // 否则该年份不是闰年
}
}
例3 求符号函数sgn(x)的Java程序
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
float x; // 定义一个float型变量x
x = sc.nextFloat(); // 键盘输入变量x的值
int sgn; // 定义一个int型变量sgn，用于保存符号函数的结果
if (x == 0) // 首先将x分为等于0和不等于0两种情况
sgn = 0; // x = 0的情况
else { // 在x不等于0时，再进一步区分x>0和x<0这两种情况
if (x > 0) sgn = 1; // x > 0的情况
else sgn = -1; // x < 0的情况
}
System.out.println( sgn ); // 显示sgn的值，即符号函数的结果
}
}
2、Java语法：if-else if语句
Java语法：if-else if语句 if (表达式1) 语句1 else if (表达式2) 语句2 ...... else if (表达式n) 语句n else 语句n+1
语法说明：
- 表达式1~n分别是需依次判断的条件。表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
- 语句1~n分别对应条件成立时执行的语句，可以是单条语句、复合语句或空语句。
- 语句n+1是所有条件都不成立时执行的语句，可以是单条语句、复合语句。如果所有条件都不成立时不需要做什么处理，即空语句，则省略else和语句n+1。
- 计算机执行该语句时，首先计算表达式1，若为true则执行语句1；否则继续计算表达式2，…，直到表达式n；如果所有条件都不成立则执行else后面的语句n+1。计算机只会执行语句1~n+1中的一条。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
float x; // 定义一个float型变量x
x = sc.nextFloat(); // 键盘输入变量x的值
int sgn; // 定义一个int型变量sgn，用于保存符号函数的结果
if (x == 0) sgn = 0; // 首先检查x等于0的情况
else if (x > 0) sgn = 1; // 再检查x大于0的情况
else sgn = -1; // 最后剩下的就是x小于0的情况
System.out.println( sgn ); // 显示符号函数的结果
}
}
例5 显示星期几英文单词的Java程序
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int x; // 定义一个int型变量x
x = sc.nextInt(); // 键盘输入一个表示星期几的数值（1~7），保存到变量x中
// 下列if-else if语句根据x的值显示其对应的英文单词
if (x == 1) System.out.println( "Monday" );
else if (x == 2) System.out.println( "Tuesday" );
else if (x == 3) System.out.println( "Wednesday" );
else if (x == 4) System.out.println( "Thursday" );
else if (x == 5) System.out.println( "Friday" );
else if (x == 6) System.out.println( "Saturday" );
else if (x == 7) System.out.println( "Sunday" );
else System.out.println( "Input Error" ); // 输入数值不在1~7范围之内，提示错误
}
}
3、Java语法：条件运算符“? :”
条件运算符“? :” int a = 5, b = 10, c; if (a > b) c = a; else c = b;
表达式 ? 表达式1 : 表达式2
语法说明：
- 条件运算符将3个表达式连接在一起，构成一个大的条件表达式。其中的表达式指定一个判断条件，该表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
- 如果表达式的结果为true，则计算表达式1，将其结果作为整个条件表达式的结果；否则计算表达式2，将其结果作为整个条件表达式的结果。
- 条件运算符为3目运算符
举例：int a = 5, b = 10, c; a>b ? a : b // 这是一个条件表达式，其结果等于10，数据类型为int型 System.out.println( a>b ? a : b ); // 显示条件表达式的结果 c = ( a>b ? a : b ); // 将条件表达式的结果赋值给变量c4、Java语法：switch-case语句
switch (表达式) {
case 常量表达式1: 语句1
case 常量表达式2: 语句2
......
case 常量表达式n: 语句n
default: 语句n+1
}
语法说明：
- 计算机执行该语句时，首先计算switch后面的表达式，然后将结果依次与各case后的常量表达式的结果进行比对。若比对成功，则以比对成功的case语句为起点，顺序执行后面的所有语句，直到整个switch-case语句结束；或遇到break语句时中途跳出switch-case语句。如果所有比对都不成功，则将default语句作为执行的起点。
- 表达式的结果应当是整型或字符型（即byte、short、int、long或char型），不能是浮点型。
- 常量表达式1~n分别列出switch后面“表达式”可能的结果。常量表达式只能是常量，或由常量组成的表达式。各常量表达式的结果不能相同。
- 语句1~n分别对应常量表达式比对成功时应执行的语句序列。通常都在末尾增加一条break语句，这样可以宣告算法结束，中途跳出。
- 语句n+1是default后面的语句，即所有比对都不成功时应执行的语句。default语句习惯上被放在最后。语句1~n+1为复合语句时，大括号也可省略。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int x; // 定义一个int型变量x
x = sc.nextInt(); // 键盘输入一个表示星期几的数值（1~7），保存到变量x中
// 下列switch-case语句根据x的值显示对应的英文单词
switch ( x ) {
case 1: System.out.println( “Monday” ); break;
case 2: System.out.println( “Tuesday” ); break;
case 3: System.out.println( “Wednesday” ); break;
case 4: System.out.println( “Thursday” ); break;
case 5: System.out.println( “Friday” ); break;
case 6: System.out.println( “Saturday” ); break;
case 7: System.out.println( “Sunday” ); break;
default: System.out.println( “Input Error” ); break;
}
// 每个case语句显示出对应的英文单词之后，程序功能即已完成
// 因此使用break语句中途跳出switch语句
}
}
例7 显示不同月份天数的Java程序（switch-case语句：共用语句）
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int month; // 定义一个int型变量month
month = sc.nextInt(); // 键盘输入一个月份（1~12），保存到变量month中
// 下列switch-case语句显示不同月份的天数
switch ( month ) {
case 1: // 1月大
case 3: // 3月大
case 5: // 5月大
case 7: // 7月大
case 8: // 8月大
case 10: // 10月大
case 12: System.out.println( “31天” ); break; // 1、3、5、7、8、10、12月共用语句
case 4: // 4月小
case 6: // 6月小
case 9: // 9月小
case 11: System.out.println( “30天” ); break; // 4、6、9、11月共用语句
case 2: System.out.println( “28或29天” ); break; // 2月
default: System.out.println( “Input Error” ); break; // 提示错误信息
}
}
}
四、循环语句
有一些算法，在满足特定条件下将重复执行某些操作步骤
奇数数列：1, 3, 5, 7, 9, …，求数列前N项的累加和
如果……，就重复做……，否则停止
如果条件成立，则重复执行循环体，否则结束循环
循环的4个要素
循环变量、循环变量的初始值、循环条件、循环体
1、Java语法：while语句while (表达式) 语句
语法说明：
- 表达式指定一个循环条件。该表达式结果必须布尔类型，例如关系表达式或逻辑表达式。
- 语句是描述循环体的Java语句，即条件成立时循环执行的算法。如循环条件一开始就不成立，则循环体一次也不执行。循环体中应包含使循环条件趋向于false的语句，否则循环条件一直为true，循环体将无休止地执行，俗称为死循环。
- 计算机执行该语句时，首先计算表达式（即循环条件），若结果为true（条件成立），则重复执行循环体语句；否则结束循环。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int N; // 定义一个int型变量N
N = sc.nextInt(); // 键盘输入变量N的值
int n = 1, sum = 0; // 定义循环变量n（初始值为1），
// 定义保存累加结果的变量sum（初始值为0）
while (n <= N) { // 用小括号将循环条件n<=N括起来
sum += 2*n - 1; // 将当前项的值2n-1累加到sum上
n++; // 将n加1，准备下一次累加。该语句使得循环条件n<=N趋向于false
// 执行完循环体最后一条语句之后，转到第11行，重新判断循环条件
}
// 如果循环条件不成立，则循环结束，继续执行while语句的下一条语句
System.out.println( sum ); // 显示变量sum的值，即前N项的累加和
}
}
2、Java语法：do-while语句
do {
语句
} while (表达式) ;
语法说明：
- 表达式指定一个循环条件。将条件放在循环体语句的后面，即先执行，再判断条件。该表达式结果必须布尔类型，例如关系表达式或逻辑表达式。
- 语句是描述循环体的Java语句，不管循环条件是否成立，循环体至少执行一次。如果循环体只包含一条语句，则大括号“{ }”可以省略。循环体中应包含使循环条件趋向于false的语句，否则将造成死循环。
- 计算机执行该语句时，首先执行一次循环体，然后再计算表达式（即循环条件），若结果为true（条件成立），则重复执行循环体语句；否则结束循环。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int N; // 定义一个int型变量N
N = sc.nextInt(); // 键盘输入变量N的值
int n = 1, sum = 0; // 定义循环变量n（初始值为1），
// 定义保存累加结果的变量sum（初始值为0）
do { // 先执行循环体
sum += 2*n - 1; // 将当前项的值2n-1累加到sum上
n++; // 将n加1，准备下一次累加
} while (n <= N) ; // 后判断条件。如条件成立则重复执行循环体，否则结束循环
// 循环结束后，继续执行do-while语句的下一条语句
System.out.println( sum ); // 显示变量sum的值，即前N项的累加和
}
}
3、Java语法：for语句
for (表达式1; 表达式2; 表达式3)
语句
语法说明：
- 表达式1只在正式循环前执行一次，通常用于为循环算法赋初始值。
- 表达式2指定一个循环条件。每次循环时，先计算该表达式，如果为true则执行下面的循环体语句，否则结束循环。
- 表达式3在每次循环体执行结束之后都被执行一次，主要用于修改循环条件中的某些变量，使循环条件趋向于false。
- 语句是描述循环体的Java语句。
- 计算机执行该语句时，首先计算表达式1（通常为赋初始值）；再计算表达式2（即循环条件），若结果为true则重复执行循环体语句，每次执行完循环体语句之后都计算一次表达式3（通常用于修改循环条件中的某些变量），然后再返回表达式2重新判断条件；若表达式2的结果为false则结束循环。
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
int N; // 定义一个int型变量N
N = sc.nextInt(); // 键盘输入变量N的值
int n, sum = 0; // 定义循环变量n
// 定义保存累加结果的变量sum（初始值为0）
for (n = 1; n <= N; n++) { // for语句集中用3个表达式指定n的初始值1、循环条件n<=N
// 以及修改循环变量n++，使循环条件趋向于false
sum += 2*n - 1; // 循环体被简化了，原来的n++语句被放入到for语句里面
} // 循环体只有一条语句，此时这对大括号可以省略
System.out.println( sum ); // 显示变量sum的值，即前N项的累加和
}
}
五、break语句和continue语句
控制语句
int a=5, b=10, c; // 将a、b中较大的数赋值给c
if (a > b)
c = a;
else
c = b;
System.out.println( c );
1、break语句
例11 一个计算圆面积的Java程序（break语句应用示例）
import java.util.Scanner; // 导入外部程序Scanner
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
Scanner sc = new Scanner( System.in ); // 创建扫描器对象sc
double r; // 定义一个变量r来存放圆的半径
while ( true ) { // 死循环
r = sc.nextDouble(); // 键盘输入圆的半径
if (r <= 0) break; // 如果用户输入的半径小于或等于0，则跳出循环
System.out.println( 3.14*r*r ); // 显示圆面积
}
// 使用break语句中途跳出while语句，继续执行while语句的下一条语句
}
}
2、多重循环
例12 生成乘法表的Java程序 （多重循环应用示例）
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
int x, y; // 定义两个循环变量x和y
for (x = 1; x <= 9; x++) { // 第一重循环，x从1到9，共9行
for (y = 1; y <= x; y++) // 第二重循环，y从1到x。第x行有x个乘法
System.out.print( y +"×" +x +"=" +(x*y) +" " );
System.out.print( 'n' ); // 换一行，再显示后续的内容
}
}
}
3、continue语句
例13 显示1~50之间所有能被3整除的数（continue语句应用示例）
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
for (int n = 1; n <= 50; n++) { // 从1到50的循环
if (n%3 != 0) continue; // 如果n不能被3整除，则执行continue语句
// continue语句的作用是结束本次循环，中途返回，去检查下一个数
// 未中途返回的数是能被3整除的数，下面将显示这些数并用逗号隔开
System.out.print( n +", " );
}
}
}
例14 显示100~200之间的所有质数（带标号的continue语句应用示例）
public class JavaTest { // 主类
public static void main(String[] args) { // 主方法
int i, j, n = 0;
Loop1: for (i = 101; i <= 200; i += 2) { // 外层循环，语句块标号Loop1
Loop2: for(j = 2; j <= i/2; j++) { // 内层循环，语句块标号Loop2
if ( i%j == 0 ) // 不是质数，则中途返回
continue Loop1; // 借助标号Loop1，直接返回外层循环
}
System.out.print( " " +i ); // 是质数：显示质数，以空格隔开
n++; // 统计显示的指数个数，一行显示10个
if ( n < 10 ) // 未满10个，则不换行
continue; // 中途返回。无标号时直接返回本层循环，此处也为外层循环
System.out.println( ); n = 0; // 换行显示，并将计数清零
}
}
}
