一、三种算法基本结构

1. 顺序结构、选择结构、循环结构
2. 条件：真（true）、假（false）
3. 布尔类型（boolean）

​ - 关系运算符：例如，大于、小于、等于

​ - 逻辑运算符：与、或、非

4. 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	比较两个算术表达式时，先计算表达式，再比较其结果。算术运算符优先级高于关系运算符。

1、关系运算符

​ 由关系表达式所描述的条件举例（假设：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吗？不是，条件不成立

2、逻辑运算符

逻辑运算符	运算规则
&&（逻辑与）	双目运算符。若两个操作数都为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. 表达式指定一个判断条件。该表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
2. 语句1是描述算法分支1的Java语句序列，即条件成立时执行的语句序列。
3. 语句2是描述算法分支2的Java语句序列，即条件不成立时执行的语句序列。如果条件不成立时不需要做什么处理，则省略else和{语句2}。
4. 语句1、语句2可能是包含多条Java语句的序列，此时必须用一对大括号{ }将它们括起来。如果只包含一条语句，则大括号可以省略。
5. 计算机执行该语句时，首先计算表达式（即判断条件），若结果为true（条件成立），则执行语句1；否则，执行else后面的语句2。

例1 实现求倒数算法的Java程序（if-else语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {  // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scdouble x;          // 定义一个double型变量xx = sc.nextDouble();  // 键盘输入变量x的值if (x != 0) {     // 判断条件“x不等于0”是否成立// 条件成立时执行下列代码。因为是多条语句，所以用{ }括起来double y;  // 再定义一个double型变量y，用于保存x的倒数y = 1 / x;  // 求x的倒数，结果赋值给ySystem.out.println( y );  // 显示y的值，即x的倒数}elseSystem.out.println( "0的倒数没有意义" );  // 显示错误信息// else分支只有一条语句，可省略大括号}
}

例2 判断年份是否闰年的Java程序

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {  // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint year;          // 定义一个int型变量yearyear = sc.nextInt();  // 键盘输入一个年份，保存到变量year中if ( (year%4 == 0 && year%100 != 0) || year%400 == 0 )  // 判断闰年条件是否成立System.out.println( year + "是闰年" );          // 条件成立则该年份是闰年elseSystem.out.println( year + "不是闰年" );            // 否则该年份不是闰年}
}

例3 求符号函数sgn(x)的Java程序

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {  // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scfloat x;           // 定义一个float型变量xx = 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. 表达式1~n分别是需依次判断的条件。表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
2. 语句1~n分别对应条件成立时执行的语句，可以是单条语句、复合语句或空语句。
3. 语句n+1是所有条件都不成立时执行的语句，可以是单条语句、复合语句。如果所有条件都不成立时不需要做什么处理，即空语句，则省略else和语句n+1。
4. 计算机执行该语句时，首先计算表达式1，若为true则执行语句1；否则继续计算表达式2，…，直到表达式n；如果所有条件都不成立则执行else后面的语句n+1。计算机只会执行语句1~n+1中的一条。

例4 求符号函数sgn(x)的Java程序（if-else if语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {  // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scfloat x;          // 定义一个float型变量xx = 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;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint x;          // 定义一个int型变量xx = 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

语法说明：

1. 条件运算符将3个表达式连接在一起，构成一个大的条件表达式。其中的表达式指定一个判断条件，该表达式结果应为布尔类型，例如关系表达式或逻辑表达式。
2. 如果表达式的结果为true，则计算表达式1，将其结果作为整个条件表达式的结果；否则计算表达式2，将其结果作为整个条件表达式的结果。
3. 条件运算符为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 );              // 将条件表达式的结果赋值给变量c

4、Java语法：switch-case语句

switch (表达式)  {
case 常量表达式1: 语句1
case 常量表达式2: 语句2
......
case 常量表达式n: 语句n
default: 语句n+1
}

语法说明：

1. 计算机执行该语句时，首先计算switch后面的表达式，然后将结果依次与各case后的常量表达式的结果进行比对。若比对成功，则以比对成功的case语句为起点，顺序执行后面的所有语句，直到整个switch-case语句结束；或遇到break语句时中途跳出switch-case语句。如果所有比对都不成功，则将default语句作为执行的起点。
2. 表达式的结果应当是整型或字符型（即byte、short、int、long或char型），不能是浮点型。
3. 常量表达式1~n分别列出switch后面“表达式”可能的结果。常量表达式只能是常量，或由常量组成的表达式。各常量表达式的结果不能相同。
4. 语句1~n分别对应常量表达式比对成功时应执行的语句序列。通常都在末尾增加一条break语句，这样可以宣告算法结束，中途跳出。
5. 语句n+1是default后面的语句，即所有比对都不成功时应执行的语句。default语句习惯上被放在最后。语句1~n+1为复合语句时，大括号也可省略。

例6 显示星期几英文单词的Java程序（switch-case语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint x;          // 定义一个int型变量xx = 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;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint month;          // 定义一个int型变量monthmonth = 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 (表达式)
语句

语法说明：

1. 表达式指定一个循环条件。该表达式结果必须布尔类型，例如关系表达式或逻辑表达式。
2. 语句是描述循环体的Java语句，即条件成立时循环执行的算法。如循环条件一开始就不成立，则循环体一次也不执行。循环体中应包含使循环条件趋向于false的语句，否则循环条件一直为true，循环体将无休止地执行，俗称为死循环。
3. 计算机执行该语句时，首先计算表达式（即循环条件），若结果为true（条件成立），则重复执行循环体语句；否则结束循环。

例8 求解奇数数列前N项累加和的Java程序（while语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint N;          // 定义一个int型变量NN = 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 (表达式) ;

语法说明：

1. 表达式指定一个循环条件。将条件放在循环体语句的后面，即先执行，再判断条件。该表达式结果必须布尔类型，例如关系表达式或逻辑表达式。
2. 语句是描述循环体的Java语句，不管循环条件是否成立，循环体至少执行一次。如果循环体只包含一条语句，则大括号“{ }”可以省略。循环体中应包含使循环条件趋向于false的语句，否则将造成死循环。
3. 计算机执行该语句时，首先执行一次循环体，然后再计算表达式（即循环条件），若结果为true（条件成立），则重复执行循环体语句；否则结束循环。

例9 求解奇数数列前N项累加和的Java程序（do-while语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint N;          // 定义一个int型变量NN = 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. 表达式1只在正式循环前执行一次，通常用于为循环算法赋初始值。
2. 表达式2指定一个循环条件。每次循环时，先计算该表达式，如果为true则执行下面的循环体语句，否则结束循环。
3. 表达式3在每次循环体执行结束之后都被执行一次，主要用于修改循环条件中的某些变量，使循环条件趋向于false。
4. 语句是描述循环体的Java语句。
5. 计算机执行该语句时，首先计算表达式1（通常为赋初始值）；再计算表达式2（即循环条件），若结果为true则重复执行循环体语句，每次执行完循环体语句之后都计算一次表达式3（通常用于修改循环条件中的某些变量），然后再返回表达式2重新判断条件；若表达式2的结果为false则结束循环。

例10 求解奇数数列前N项累加和的Java程序（for语句）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scint N;          // 定义一个int型变量NN = sc.nextInt();  // 键盘输入变量N的值int n, sum = 0;  // 定义循环变量n// 定义保存累加结果的变量sum（初始值为0）for (n = 1; n <= N; n++) {  // for语句集中用3个表达式指定n的初始值1、循环条件n<=N// 以及修改循环变量n++，使循环条件趋向于falsesum += 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;
elsec = b;
System.out.println( c );

1、break语句

例11 一个计算圆面积的Java程序（break语句应用示例）

import java.util.Scanner;  // 导入外部程序Scannerpublic class JavaTest {    // 主类public static  void main(String[] args) {     // 主方法Scanner sc = new Scanner( System.in );  // 创建扫描器对象scdouble 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) {    // 外层循环，语句块标号Loop1Loop2: for(j = 2; j <= i/2; j++) {     // 内层循环，语句块标号Loop2if ( i%j == 0 )         // 不是质数，则中途返回continue Loop1;  // 借助标号Loop1，直接返回外层循环}System.out.print( " " +i );  // 是质数：显示质数，以空格隔开n++;                  // 统计显示的指数个数，一行显示10个 if ( n < 10 )     // 未满10个，则不换行continue;  // 中途返回。无标号时直接返回本层循环，此处也为外层循环System.out.println( );    n = 0;  // 换行显示，并将计数清零}}
}