在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
顺序控制
分支控制
循环控制
程序从上到下逐行地执行，中间没有任何判断和跳转。
先定义再使用
让程序有选择的的执行,分支控制有三种
单分支 if
基本语法：
if(条件表达式){
执行代码块;(可以有多条语句)
}
说明:当条件表达式为ture时，就会执行{}的代码。如果为false ,就不执行.特别说明，如果{}中只有一条语句,则可以不用{} 但是建议写上
/*编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
则输出 "你年龄大于18,要对自己的行为负责,送入监狱"*/
import java.util.Scanner;
public class If01 {
public static void main(String[] args) {
//思路分析：
//1. 接收输入的年龄, 应该定义一个Scanner 对象
//2. 把年龄保存到一个变量 int age
//3. 使用 if 判断，输出对应信息
//定义一个Scanner 对象
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄:");
//把年龄保存到一个变量 int age
int age = myScanner.nextInt();
//使用 if 判断，输出对应信息
if (age>18){
System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
}
System.out.println("程序继续...");
}
}
双分支 if-else
基本语法:if(条件表达式){
执行代码块1;
}
else {
执行代码块2;
}
说明:当条件表达式成立，即执行代码块1，否则执行代码块2。如果执行代码块只有一条语句，则可以省略，否则，不能省略。
/*编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
则输出 "你年龄大于18,要对自己的行为负责, 送入监狱"。
否则 ,输出"你的年龄不大这次放过你了."*/
import java.util.Scanner;
public class If02 {
public static void main(String[] args) {
//思路分析：
//1. 接收输入的年龄, 应该定义一个Scanner 对象
//2. 把年龄保存到一个变量 int age
//3. 使用 if-else 判断，输出对应信息
//定义一个Scanner 对象
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄:");
//把年龄保存到一个变量 int age
int age = myScanner.nextInt();
//使用 if 判断，输出对应信息
if (age>18){
System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
} else {
System.out.println("你的年龄不大这次放过你了");
}
System.out.println("程序继续...");
}
}
多分支 if-else if -....-else
基本语法:
if (条件表达式1){
执行代码块1;
}
else if(条件表达式2){
执行代码块2;
}
... else{
执行代码块n;
}
特别说明:
(1)多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
(2)如果有else ,如果所有的条件表达式都不成立，则默认执行else代码块
/* 输入保国同志的芝麻信用分：
如果：
信用分为100分时，输出 信用极好；
信用分为(80，99]时，输出 信用优秀；
信用分为[60,80]时，输出 信用一般；
其它情况 ，输出 信用 不及格
请从键盘输入保国的芝麻信用分，并加以判断
假定信用分数为int
*/
import java.util.Scanner;
public class If03 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
//接收用户输入
System.out.println("保国同志的芝麻信用分为：");
int grade = myScanner.nextInt();
//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误
if(grade >=1 && grade <= 100) {
if (grade == 100) {
System.out.println("信用极好");
} else if (grade > 80 && grade <= 99) {
System.out.println("信用优秀");
} else if (grade > 60 && grade <= 80) {
System.out.println("信用一般");
} else {
System.out.println("信用不及格");
}
} else {
System.out.println("信用分需要在1-100,请重新输入");
}
}
}
在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过 3 层 （可读性不好）
/*参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。
并且根据性别提示进入男子组或女子组。
输入成绩和性别，进行判断和输出信息。*/
import java.util.Scanner;
public class NestedIf {
public static void main(String[] args) {
//思路分析
//1. 创建Scanner对象，接收用户输入
//2. 接收 成绩保存到 double score
//3. 使用 if-else 判断 如果初赛成绩大于8.0进入决赛，否则提示淘汰
//4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入该歌手的成绩");
double score = myScanner.nextDouble();
if (score > 8.0){
System.out.println("请输入性别");
char gender = myScanner.next().charAt(0);
if (gender == '男'){
System.out.println("进入男子组");
} else if (gender == '女'){
System.out.println("进入女子组");
} else {
System.out.println("输入性别有误，不能参加决赛~");
}
} else {
System.out.println("sorry，你被淘汰了~");
}
}
}
基本语法：
switch(表达式){
case常量1://当..
语句块1;
break;
case常量2;
语句块2;
break;
…
case常量n;
语句块n;
break;
default:
default语句块;
break;
}
switch关键字，表示swtich分支
表达式 对应一个值
case常量1:当表达式的值等于常量1，就执行语句块1
break :表示退出swtich
如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2
如果一个都没有匹配上，执行default
switch 注意事项和细节讨论:
表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
switch(表达式)中表达式的返回值必须是:(byte,short,int,char,enum[枚举].String)
case子句中的值必须是常量,而不能是变量
default子句是可选的，当没有匹配的case时，执行default
break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有写break，程序会顺序执行到switch结尾，除非遇到break;
import java.util.Scanner;
public class SwitchExercise {
public static void main(String[] args) {
/* 使用 switch 把小写类型的char型转为大写(键盘输入)。
只转换 a->A, b->B, c, d, e. 其它的输出 "other"。*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入a-z");
char c1 = myScanner.next().charAt(0);
switch (c1) {
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other");
break;
}
/*对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。
(注：输入的成绩不能大于100)*/
//思路分析
//1. 这道题，可以使用分支来完成， 但是要求使用switch
//2. 这里我们需要进行一个转换, 编程思路 :
// 如果成绩在 [60,100] , (int)(成绩/60) = 1
// 如果成绩在 [0,60) , (int)(成绩/60) = 0
Scanner myScanner2 = new Scanner(System.in);
System.out.println("请输入分数");
double score = myScanner2.nextDouble();
if (score >= 0 && score <= 100) {
switch ((int) (score / 60)) {
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
default:
System.out.println("输入有误");
}
} else {
System.out.println("输入的成绩在0-100");
}
/*根据用于指定月份，
打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 */
Scanner myScanner3 = new Scanner(System.in);
System.out.println("请输入月份");
int month = myScanner3.nextInt();
switch (month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("输入有误");
}
}
}
如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广。
听其名而知其意,就是让你的代码可以循环的执行
基本语法：
for(循环变量初始化;循环条件;循环变量迭代){
循环操作(可以多条语句); }
说明:
for 关键字，表示循环控制
for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
如果循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略
注意事项和细节说明:
循环条件是返回一个布尔值的表达式
for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
public class ForExercise {
public static void main(String[] args) {
//打印1~100之间所有是9的倍数的整数，统计个数及总和.[化繁为简,先死后活]
/*(技巧)
1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值*/
//思路分析
//化繁为简
//(1) 完成 输出 1-100的值
//(2) 在输出的过程中，进行过滤，只输出9的倍数 i % 9 ==0
//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
int count = 0;
int sum = 0;
int start = 1;
int end = 100;
int t = 9;
for(int i = start; i <= end; i++){
if(i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}
基本语法： 循环变量初始;
while(循环条件){
循环体(语句);
循环变量迭代;
说明： 1）while循环也有四要素。
2）只是四要素放的位置和for不一样。
public class WhileExercise {
public static void main(String[] args) {
// 打印1—100之间所有能被3整除的数
// 化繁为简, 先死后活
int i = 1;
int endNum = 100;
while (i <= endNum) {
if (i % 3 == 0) {
System.out.println(i);
}
i++;
}
System.out.println("=======================");
// 打印40—200之间所有的偶数
// 化繁为简, 先死后活
int j = 40;
int end = 200;
int k = 2;
while (j <= end){
if (j % k == 0){
System.out.println(j);
}
j++;
}
}
}
基本语法:
循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);
说明:
do while 是关键字
也有循环四要素, 只是位置不一样
先执行，再判断，也就是说，一定会至少执行一次
最后 有一个 分号 ;
while 和 do..while 区别举例: 要账
public class DoWhileExercise01 {
public static void main(String[] args) {
//统计1---200之间能被5整除但不能被3整除的个数
//化繁为简
//(1) 使用do-while输出 1-200
//(2) 过滤 能被5整除但不能被3整除的数 %
//(3) 统计满足条件的个数 int count = 0;
//先死后活
//(1) 范围的值 1-200 你可以做出变量
//(2) 能被5整除但不能被3整除的 , 5 和 3 可以改成变量
int i = 1;
int count = 0;
do {
if (i % 5 == 0 && i % 3 != 0) {
System.out.println(i);
count++;
}
i++;
}while(i <= 200);
System.out.println("count=" + count);
}
}
import java.util.Scanner;
public class DoWhileExercise02 {
public static void main(String[] args) {
//如果李三不还钱，则老马将一直使出五连鞭，直到李三说还钱为止
//[System.out.println("老马问：还钱吗？y/n")]
//化繁为简
//(1) 不停的问还钱吗?
//(2) 使用char answer 接收回答, 定义一个Scanner对象
//(3) 在do-while 的while 判断如果是 y 就不在循环
Scanner myscanner = new Scanner(System.in);
char answer = ' ';
do {
System.out.println("老马使出五连鞭~");
System.out.println("老马问：还钱吗？y/n");
answer = myscanner.next().charAt(0);
System.out.println("他的回答是" + answer);
}while(answer != 'y');
System.out.println("李三还钱了");
}
}
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。
import java.util.Scanner;
public class MulForExercise01 {
public static void main(String[] args) {
//统计3个班成绩情况，每个班有5名同学，
//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
//统计三个班及格人数，每个班有5名同学。
//思路分析:
//化繁为简
//(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
//1.1 创建 Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级5个学生的成绩累积
//(2) 统计3个班(每个班5个学生) 平均分
//(3) 所有班级的平均分
//3.1 定义一个变量，double totalScore 累积所有学生的成绩
//3.2 当多重循环结束后，totalScore / (3 * 5)
//(4) 统计三个班及格人数
//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
//4.2 如果 >= 60 passNum++
//(5) 可以优化[效率，可读性, 结构]
Scanner myscanner = new Scanner(System.in);
double totalScore = 0; //累积所有学生的成绩
int passNum = 0;//累积及格人数
int classNum = 3; //班级个数
int stuNum = 5;//学生个数
for (int i = 1; i <= classNum ;i++) {//i 表示班级
double sum = 0;
for (int j = 1; j <= stuNum ; j++) {//j 表示学生
System.out.println("请输入第" + i + "个班的第" + j + "个学生的成绩");
double score = myscanner.nextDouble();
//当有一个学生成绩>=60, passNum++
if (score >= 60){
passNum++;
}
sum += score;
System.out.println("成绩为" + score);
}
//因为sum 是 5个学生的总成绩
System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum ));
totalScore += sum;
}
System.out.println("三个班总分="+ totalScore +
"平均分=" + totalScore / classNum*stuNum);
System.out.println("及格人数="+ passNum);
}
}
public class MulForExercise02 {
public static void main(String[] args) {
//九九乘法表
int i;
int j;
for (i = 1 ; i <= 9 ; i++){
for (j = 1 ; j <= i ; j++){
System.out.print(i + "*" + j + "=" + i * j + "\t");
}
System.out.println();//换行
}
}
}
public class Stars {
public static void main(String[] args) {
/*
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第1层 有 1个*
** //第2层 有 2个*
*** //第3层 有 3个*
**** //第4层 有 4个*
***** //第5层 有 5个*
3. 打印整个金字塔
* //第1层 有 1个* 2 * 1 -1 有4=(总层数-1)个空格
*** //第2层 有 3个* 2 * 2 -1 有3=(总层数-2)个空格
***** //第3层 有 5个* 2 * 3 -1 有2=(总层数-3)个空格
******* //第4层 有 7个* 2 * 4 -1 有1=(总层数-4)个空格
********* //第5层 有 9个* 2 * 5 -1 有0=(总层数-5)个空格
4. 打印空心的金字塔 [最难的]
* //第1层 有 1个* 当前行的第一个位置是*,最后一个位置也是*
* * //第2层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第3层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第4层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
********* //第5层 有 9个* 全部输出*
先死后活
5 层数做成变量 int totalLevel = 5;
*/
int totalLevel = 5;
for (int i = 1; i <= totalLevel; i++) {//i表示层数
//在输出*之前还有空格输出（总层数-当前数）
for (int k = 1; k <= totalLevel - i; k++) {
System.out.print(" ");
}
//控制打印每层的*个数
for (int j = 1; j <= 2 * i - 1; j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印一行*，就换行
System.out.println();
}
}
}
基本介绍：
break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]中
基本语法：
{
……
break;
……
}
说明:
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
标签的基本使用: label1: { ......
label2: {......
label3: {...... break label2;
....... } } }
(1)break语句可以指定退出哪层
(2)label1是标签，名字由程序员指定
(3)break后指定到哪个label就退出到哪里
(4)在实际的开发中，尽量不要使用标签
(5)如果没有指定break,默认退出最近的循环体
import java.util.Scanner;
public class BreakExercise02 {
public static void main(String[] args) {
//实现登录验证，有3次机会，如果用户名为"丁真" ,密码"666"提示登录成功，
//否则提示还有几次机会，请使用for+break完成
//
// 思路分析
// 1. 创建Scanner对象接收用户输入
// 2. 定义 String name ; String passwd; 保存用户名和密码
// 3. 最多循环3次[登录3次]，如果 满足条件就提前退出
// 4. 定义一般变量 int chance 记录还有几次登录机会
Scanner myscanner = new Scanner(System.in);
String name;
String passwd;
int chance = 3;
for (int i = 1; i <= 3; i++){
System.out.println("请输入名字：");
name = myscanner.next();
System.out.println("请输入密码：");
passwd = myscanner.next();
if("丁真".equals(name) && "666".equals(passwd)) {
System.out.println("恭喜你，登录成功~");
break;
}
//登录的机会就减少一次
chance--;
System.out.println("你还有" + chance + "次登录机会");
}
}
}
基本介绍：
continue 语句用于结束本次循环，继续执行下一次循环。
continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的使用的规则一样。
基本语法：
{
……
continue;
……
}
有多个循环条件时返回最近的循环。
public class ContinueDetail {
//编写一个main方法
public static void main(String[] args) {
//代码
int i = 1;
while( i <= 4) {
i++;
if( i == 2) {
continue;
}
System.out.println("i=" + i);
}
}
}
return 使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果 return 写在 main 方法，退出程序。
public class Return01 {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
if(i==3) {
System.out.println("111"+i);
return; //当return用在方法时，表示跳出方法，如果使用在main,表示退出程序
//用return结果为：Hello World! Hello World! 111
//用break结果为：Hello World! Hello World! 111 go on...
//用continue结果为：Hello World! Hello World! 111 Hello World! Hello World! go on...
}
System.out.println("Hello World!");
}
System.out.println("go on..");
}
}
某人有100,000元,每经过一次路口，需要交费,规则如下: 1) 当现金>50000时,每次交5% 2) 当现金<=50000时,每次交1000 编程计算该人可以经过多少次路口, 要求: 使用 while + break方式完成
public class Homework01 {
public static void main(String[] args) {
/*
某人有100,000元,每经过一次路口，需要交费,规则如下:
1) 当现金>50000时,每次交5%
2) 当现金<=50000时,每次交1000
编程计算该人可以经过多少次路口, 要求: 使用 while + break方式完成
思路分析
1. 定义 double money 保存 100000
2. 根据题的要求，我们分析出来有三种情况
money > 50000
money >=1000 && money <= 50000
money < 1000
3. 使用多分支 if-elseif-else
4. while+break[money < 1000], 同时使用一个变量count来保存通过路口
*/
double money = 100000;
int count = 0;
while (true){
if (money > 50000){
money *= 0.95;
count++;
} else if(money > 1000 && money < 50000 ){
money = money - 1000;
count++;
} else {
break;
}
}
System.out.println("100000 可以过 " + count + " 个路口..");
System.out.println("剩余钱数："+money);
}
}
判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。 例如： 153 = 111 + 333 + 555
import java.util.Scanner;
public class Homework02 {
public static void main(String[] args) {
/*
判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，
其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
思路分析
1. int n;
2. 先得到 n的百位，十位 ，各位的数字, 使用 if 判断他们的立方和是否相等
3. n的百位 = n / 100
4. n的十位 = n % 100 / 10
5. n的各位 = n % 10
6. 判断即可
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个三位整数：");
int n = myScanner.nextInt();
if (n < 100 || n > 999 ){
System.out.println("请输入三位数");
} else {
int a = n / 100;
int b = n % 100 / 10;
int c = n % 10;
if (a*a*a+b*b*b+c*c*c == n){
System.out.println(n + "是水仙花数");
} else {
System.out.println(n + "不是水仙花数");
}
}
}
}
输出1-100之间的不能被5整除的数，每5个一行
public class Homework3 {
public static void main(String[] args) {
/*
输出1-100之间的不能被5整除的数，每5个一行
思路分析
1. 先输出1-100的所有数
2. 然后过滤输出 不能被5整除的数 i % 5 !=0
3. 每5个一行, 我们使用 int count 统计输出的个数 当 count%5=0就说明
输出了5个，这时，我们输出 一个换行即可控制
*/
int count = 0;//统计输出个数
for (int i = 1; i <= 100; i++){
if (i % 5 != 0){
count++;
System.out.print(i + "\t");
//判断,每满5个就输出一个换行
if (count % 5 == 0){
System.out.println();
}
}
}
}
}
输出小写的a-z以及大写的Z-A
public class Homework04 {
public static void main(String[] args) {
/* 输出小写的a-z以及大写的Z-A
思路分析
1. 'b' = 'a' + 1 c = 'a' + 2
2. 使用for搞定*/
for (char c1 = 'a'; c1 <= 'z'; c1++ ){
System.out.print(c1 + " ");
}
System.out.println(" ");
for(char c1 = 'Z'; c1 >= 'A'; c1--) {
System.out.print(c1 +" ");
}
}
}
求出1-1/2+1/3-1/4…..1/100的和
public class Homework05 {
public static void main(String[] args) {
/*
求出1-1/2+1/3-1/4…..1/100的和
思路分析
1. 1-1/2+1/3-1/4…..1/100 = (1/1)-(1/2)+(1/3)-(1/4)...1/100
2. 从上面的分析我们可以看到
(1) 一共有100数 ， 分子为1 , 分母从1-100
(2) 还发现 当分母为奇数时，前面是 +, 当分母是偶数时，前面是-
3. 我们可以使用 for + 判断即可完成
4. 把结果存放到 double sum
5. 这里有一个隐藏的陷阱，要把 公式分子 1 写出1.0 才能得到精确的小数
*/
double sum = 0;
for (int i = 1; i <= 100; i++){
if (i % 2 != 0){
sum += 1.0/i;
}else {
sum -= 1.0/i;
}
}
System.out.println("sum=" + sum);
}
}
求(1)+（1+2）+（1+2+3）+（1+2+3+4）+...+(1+2+3+..+100)的结果
public class Homework06 {
public static void main(String[] args) {
/*
求(1)+（1+2）+（1+2+3）+（1+2+3+4）+...+(1+2+3+..+100)的结果
思路分析
1. 一共有100项相加
2. 每一项的数字在逐渐增加
3. 很像一个双层循环
i 可以表示是第几项,同时也是当前项的最后一个数
4. 使用 sum 进行累计即可 */
int sum = 0;
for (int i = 1; i <= 100; i++ ){//i可以表示第几项,同时也是当前项的最后一个数
for (int j = 1; j <= i; j++){//内层对1-i进行循环
sum += j;
}
}
System.out.println("sum="+sum);
}
}
本文章使用limfx的vscode插件快速发布