目录
使用while循环计算1+1/2!+1/3!+…+1/20!
使用while循环计算1+1/2!+1/3!+…+1/20!
算法思维：由题目我们得知，该等式总共有20项。等式呈现的特点是:a.分子始终为1；b.分母为1!、2！、3！、4！…20!的阶乘。针对这种特点式子我们可以由简单到复查逐步实现，我们可以先简单思考1+1/2+1/3+…+1/20的实现-分母1-20我们可以使用for/while循环语句、i++来实现。其次，思考如何计算阶乘。
例如5!=5*4*3*2*1 = 1*2*3*4*5 =1*1*（1+1）*（1+1+1）*（1+1+1+1）*（1+1+1+1+1）
所以得出阶乘循环体：
double a=1;
double n=1;
while(a<=20) { n=a*n; a++;}
进一步二者结合便得出题干代码（见主代码）。
package experiment;
public class factorial {
public static void main(String[] args) {
// TODO 自动生成的方法存根
double a=1;
double n=1;
double f=0;
double sum=0;
while(a<=20) {
n=a*n; //求阶乘
f=1/n;
sum=sum+f;
a++;
}
System.out.println("1 + 1/2! + 1/3! + ... + 1/20! = "+sum);
}
}
运行结果：
使用for循环输出空心菱形与实心菱形
算法思维：首先我们需要有拆分与拼接的思维，由图我们可以看出菱形是有上下对称的两个三角形组成的，而这个三角形是有一行行的“空格 ＋ *”构成的。如果我们固定思维直接输出这个菱形是很困难的，我们可以先从输出一行 * 思考，依次类推。通过观察我们得知，上部分实体三角形 a.第一行有1个 * ，第二行有2个 * ，第三行有3个 * ，第四行有4个 * …. 第n行有n个 * 执行语句如下：
for (int j = 0; j <= i; j++) {System.out.print("* ");}
b.每行的 * 与 * 之间有一个 空格 ，所以输出的*后加个空格，例如 ：System.out.print("* ");
c.以5行为例，第5行的第一个 * 前有0个空格，第4行的第一个 * 前有1个空格，第3行的第一个 * 前有2个空格，第2行的第一个 * 前有3个空格，第1行的第一个 * 前有4个空格 。得出5+0=5,4+1=5,3+2=5，2+3=5,1+4=5
那么第 i 行的第一个 * 前有5-i个空格，继续推，那么以n行为例，第 i 行的第一个 * 前有 n-i 个空格。如果我们使用for循环语句则有
for (int i = 0; i < num; i++) {
for (int j = 0; j < num - i - 1; j++) {
System.out.print(" ");}
}
第1行有num-1个空格 ，如果i从0 开始 到i < num结束，可以判断出共有num行，j=0 ~ j<num-i-1，如果感觉抽象我们代个数，num=5,i=0为第1行，需要输出5-0-1=4个空格 0~4为4个空格,1+4=5=num。i=4为最后一行（第5行），需要输出5-4-1=0个空格,0+5=5=num。接着我们继续输出 * 第1行1个 * 第2行2个 * 第n行n个 *
for (int j = 0; j <= i; j++) { //执行时j=1,空格循环已经执行完毕
System.out.print("* ");
}System.out.println(); //换行
下半实体三角是与上半实体三角共用中间对称行 num 行，因此我们从num-1行到1行共num-1行实现，可以仿照上半实体三角逆推规律。我们依旧以5为例子共4行，倒数第4行的第一个 * 前有1个空格，倒数第3行的第一个 * 前有2个空格，倒数第2行的第一个 * 前有3个空格，倒数第1行的第一个 * 前有4个空格，那么倒数第 I 行前面有 5-I 个空格。同样倒数第4行有4个 * ，同样倒数第3行有3个 * ，同样倒数第2行有2个 * ，同样倒数第1行有1个 * ，那么倒数第 I 行前面有 I 个空格。所以代码如下
for (int i = 0; i < num - 1; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(" ");
}
for (int j = 0; j <= num - i - 2; j++) {//num-1-i-1=num-i-2
System.out.print("* ");
}
System.out.println();
}
空心菱形思路如下：我们同样观察得知，第1行有1个* ，第2行有2个* ，第3行有2个* …第n行有2个* 。我们还是以5行为例，第1行的第一个* 前有4个空格，第2行的第一个* 前有3个空格，第3行的第一个* 前有2个空格，第4行的第一个* 前有1个空格，第5行的第一个* 前有0个空格，行数+空格数=5。我们依旧是按部就班先输入空格再输入* ，依旧以5行为例，第1行我们先输入4个空格，前4个位置打印空格，第5个位置打印* ，因为第一行我们需要输入1个* ，第2行我们先输入3个空格，前3个位置我们打印空格，因为是第2行所以我们需要打印两个* ，并且以第5个位置为对称中心，第4个位置打印* ，第5个位置已经为空格，根据对称要求，第6个位置我们打印出* ，这时我们是否可以把第4个位置* ，视为位置1，把第6个位置* ，视为位置2，第3行我们先输入2个空格，前2个位置我们打印空格，因为是第3行所以我们需要打印两个* ，并且以第5个位置为对称中心，第3个位置打印* ，第7个位置我们打印出* ，这时我们是否可以把第3个位置* ，视为位置1，把第7个位置* ，视为位置3，把5、6位置视为一个位置打印2个 空格 ，依次类推我们可以得出当我们行数等于要打印的实心个数或者要打印* ，的第一个位置时我们就输出* ，其他情况打印2个空格。
for (int j = 1; j <= i; j++) {
if (j == 1 || j == i) {
System.out.print("* ");
} else {
System.out.print(" ");
}
下半空三角结合实体下三角起始位置减去1行也能实现。
package experiment;
import java.util.Scanner;
public class Rhombus01 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要打印的菱形:");
int num = sc.nextInt();
System.out.println("空心菱形");
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= num - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
if (j == 1 || j == i) {
System.out.print("* ");
} else {
System.out.print(" ");
}
}
System.out.println();
}
for (int i = 1; i <= num - 1; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= num - i; j++) {
if (j == 1 || j == num - i) {
System.out.print("* ");
} else {
System.out.print(" ");
}
}
System.out.println();
}
System.out.println("实体菱形");
for (int i = 0; i < num; i++) {
for (int j = 0; j < num - i - 1; j++) {
System.out.print(" ");
}
for (int j = 0; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
for (int i = 0; i < num - 1; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(" ");
}
for (int j = 0; j <= num - i - 2; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}运行结果：
判断闰年
算法思维：该实验我们只需要知道闰年的判断条件是（if-else条件判断语句） ：year%4==0&&year%100==0||year%400==0 然后基本java输入输出语句实现。
package experiment;
import java.util.Scanner;
public class Leap_year {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份：");
int year=sc.nextInt();
if(year%4==0&&year%100==0||year%400==0){
System.out.println(year+"是闰年");
}else{
System.out.println(year+"是平年");
}
}
}运行结果：
输入月份输出季节
算法思维：该实验我们需要知道：
3、4、5月为春季
6、7、8月为夏季
9、10、11月为秋季
12、1、2月为冬季
我们可以利用Switch语句判断，case可以从1-12，但是代码较多，这时我们可以利用int 类型除法结果必须为int类型这一特点 在Switch( )中添加表达式 ，即switch(month/3) 因为3个月为一季度所以除以3。
package experiment;
import java.util.Scanner;
public class Season {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.print("请输入月份：");
Scanner scan=new Scanner(System.in);
int month =scan.nextInt();
switch(month/3) {
case 1:
System.out.print("春天");
break;
case 2:
System.out.print("夏天");
break;
case 3:
System.out.print("秋天");
break;
default:
System.out.print("冬天");
}
}
}运行结果：
打印九九乘法表
算法思维：因为是九九乘法表，涉及到行列变化我们可采用双重for循环语句，九九乘法表第一个因数可作为列数，第二个因数可做行数。同一列第一个因数不变，同一行第二个因数不变的原则，所以使用for循环嵌套完成，又因为第一个因数要小于等于第二个因数，所以嵌套的（内循环）for循环语句条件一定为上一级循环（外循环）的循环变量，例如外循环为i=0~9,内循环须为j=1~i。当两个因数相等时输出一个换行符结，该行循环结束，继续执行下一行。"\t"是Java语言默认的制表符号，使用此符号，打印出来的乘法表格较为美观。
package experiment;
public class Multiply {
public static void main(String[] args) {
// TODO 自动生成的方法存根
for(int i=1;i<=9;i++) {
for(int j=1;j<=i;j++) {
System.out.print(" "+j+"*"+i+"="+(j*i)+"\t");
//"\t"是Java语言默认的制表符号，使用此符号，打印出来的乘法表格较为美观
if(i==j) {
System.out.print("\n");//当条件成立时，进行换行打印
}
}运行结果：
流程控制语句知识总结
Java中流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。其流程控制方式采用结构化程序设计中规定的三种基本流程结构（顺序结构，选择结构，循环结构）。
顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转。
分支结构：选择结构有两类（if，Switch）
循环结构：while，do...while，for循环
一.选择结构
1.if语句
if(条件表达式) //首先计算关系表达式的值
{
执行代码块； //如果关系表达式的值为true就执行语句体,如果关系表达式的值为false就不执行语句体
} // 继续执行后面的语句内容
2.if-else语句
if(条件表达式) //首先计算关系表达式的值
{
执行代码块1； //如果关系表达式的值为true就执行语句体1
}
else{
执行代码块2； //如果关系表达式的值为false就执行语句体2
} // 继续执行后面的语句内容
3.if-else if 语句
if（条件表达式1）//首先计算关系表达式1的值
{
执行代码块1； //如果关系表达式1的值为true就执行语句体1
}
else if（条件表达式2）//计算关系表达式2的值
{
执行代码块2； //如果关系表达式2的值为true就执行语句体2
}
......
else{ //如果以上关系表达式的值都为false就执行语句体n
执行代码块n；
} // 继续执行后面的语句内容
else 子句不能单独作为语句使用，它必须和if配对使用，else总是与它最近的if匹配，可以通过使用{}来改变匹配关系。{}遵循就近匹配原则。
4.switch语句
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
...
default:
语句体n+1;
break; //最后一个可以省略
执行流程：
1.首先计算表达式的值
2.以此和case后面的值进行比较，如果有对应值，就会执行相应语句，在执行过程中，遇到break就会结束
3.如果所有的case的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束
注意：
1.case子句中的值必须是常量(整形或字符型，不支持long类型)，不能是变量名或不确定的表达式值；
2.同一个switch语句，所有case子句中的常量值互不相同；
3.break表示中断结束的意思，用来结束switch语句，该语句用来在执行完一个case分支后使程序跳出switch语句块；
4.如果没有break，程序会顺序执行到 switch结尾 ;
5.default表示所有情况都不匹配的时候，就执行该处内容，和if语句中的else相似，该子句是可任选的,同时，位置也是灵活的。当没有匹配的case时，执行default。
二.循环结构
循环四要素：初始化变量，循环条件，循环操作，改变变量的值（防止死循环）。
1.while循环（先判断在执行）
while（循环条件判断） //执行条件判断语句，看其结果为true还是false，如果是false，循环结束；如果是true，继续执行
{
循环操作； // 执行循环体语句
条件控制语句; // 执行条件控制语句,返回到循环条件判断语句继续
}
2.do-while循环（先执行在判断）
do{
循环操作； //执行循环体语句
条件控制语句; //执行条件控制语句
}while（循环条件判断）；
// 执行条件判断语句，看其结果为true还是false,如果是false，循环结束；如果是true，继续返回到循环操作继续执行
3.for循环
for(参数初始化；条件判断；更新循环变量){
//先执行初始化语句，执行条件判断语句，且看结果是true还是false
//如果是false，循环结束；如果是true，继续执行循环体语句
循环操作；
//执行条件控制语句(更新循环变量),再返回到条件判断语句继续循环执行
}
注意：do…while：先输出一次再进行判断（最少输出一次）
for、while：先判断再输出
for循环结束后变量不能使用
while循环结束后还可以使用（打印变量次数）
跳转控制语句区别：continue：用于循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次执行，如果用于while，do-while,for中，是可跳出循环执行循环后面的语句，如果用在Switch语句中，跳出整个循环；break：用于循环中，基于条件控制，终止循环体内容执行，结束当前整个循环，它只能用在循环里面，跳过循环体中剩余的语句执行下一次循环;return 结束一个方法。