题目1：输出1-100
明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
数字（1-100）
一个程序，输出1-100
举例：1 2 3...100
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输出1-100
(3).明确数据
输入
/
输出
1-100
提示语
输入
/
运算
/
输出
/
(4).明确动作
输入
/
运算
/
输出
println/print?
(5).重述需求
用一个Console程序，输出1-100
1 2 3...100
任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：定义变量
任务2：运算（判断条件）
任务3：输出变量
任务4：变量++
任务5：运算（判断条件）
任务6：输出变量
任务7：变量++
......
任务x：运算（判断条件）
任务x：输出变量
任务x：变量++
实现（任务拆分的结果）
任务1：定义变量
步骤
思维过程
实现
找动作
类型：int
int
找数据
一个变量
s=1;
实现
动作+数据
int s=1;
任务2：运算（判断条件）
步骤
思维过程
实现
找动作
变量<=?
?<=?
找数据
已知：变量： s 条件值：100
s 100
实现
动作+数据
sz<=100;
任务3：输出变量
步骤
思维过程
实现
找动作
输出：println/print
println
找数据
s=1;
实现
动作+数据
System.out.println(s);
任务4：变量++
步骤
思维过程
实现
找动作
变量加1
++
找数据
s
实现
动作+数据
s++;
…………
有重复，用循环（for）
四要素：
初始化：int s=1;
循环条件：s<=100;
循环体：System.out.println(s);
迭代：s++;
public class R01If {
public static void main(String[] args) {
for(int s=1;sz<=100;s++) {
System.out.println(s);
}
}
}
测试
题目2：
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
科目：固定/输入/随机？
一个输入的科目名称
一个程序，输入科目名称，求每科成绩
举例：输入文史，输出你的文史成绩是：60 及格
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，求科目成绩
(3).明确数据
输入
科目名称
输出
科目成绩
提示语
输入
请输入你需要查询的科目（输入退出结束）：
运算
/
输出
你的文史成绩是：
(4).明确动作
输入
Scanner
运算
求科目成绩
输出
println/print?
(5).重述需求
用一个Console程序，输入科目名称，求出每科的考试成绩
你的考试成绩是：60 及格
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出提示语
任务2：输入读入
任务3：运算（判断条件）
任务4：输出你的语文成绩是：60 及格
任务5：输出提示语
任务6：输入读入
任务7：运算（判断条件）
任务8：输出你的数学成绩是：60 及格
……
任务xx：输入读入
任务xx：运算（判断条件）
任务xx：输出xx
3.实现（任务拆分的结果）
任务1：输出提示语
步骤
思维过程
实现
找动作
print/println
print
找数据
字符串
“请输入你需要查询的科目（输入退出结束）：”
实现
动作+数据
System.out.print("请输入你需要查询的科目（输入退出结束）：");
任务2：输入读入
步骤
思维过程
实现
找动作
输入的值
Scanner
找数据
类型：String
名字：CD
String CD
实现
动作+数据
String CD=sc.next();
任务3：运算（判断条件）
步骤
思维过程
实现
找动作
CD=?
if
找数据
语文
CD.contentEquals("语文")
实现
动作+数据
if(CD.contentEquals("语文"))
任务4：输出你的语文成绩是：60 及格
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“你的语文成绩是：60 及格”
实现
动作+数据
System.out.println("请输入你需要查询的科目（输入退出结束）：");
…………
有重复，用循环（while）
四要素：
1.初始化：System.out.print("请输入你要查询的科目（输入退出结束）：");
String CD=sc.next();
循环条件：km.contentEquals("退出")==false
循环体：if(){}else{}
迭代：System.out.print("请输入你要查询的科目（输入退出结束）：");
CD=sc.next();
public class R02If{
public static void main(String[] args) {
Scanner sc=new Scanner (System.in);
String CD=getCourse(sc);
while(CD.contentEquals("退出")==false) {
if(CD.contentEquals("语文")){
System.out.println("你的语文成绩是：60 及格");
CD=getCourse(sc);
}else if(km.contentEquals("数学")) {
System.out.println("你的数学成绩是：10 不及格");
CD=getCourse(sc);
}else if(CD.contentEquals("计算机")) {
System.out.println("你的计科成绩是：100 优秀");
CD=getCourse(sc);
}else if(km.contentEquals("java")) {
System.out.println("你的专业成绩是：90 优秀");
CD=getCourse(sc);
}else if(CD.contentEquals("文史")) {
System.out.println("你的文史成绩是：80 良好");CD=getCourse(sc);
}else if(CD.contentEquals("军训")){
System.out.println("你的军训成绩是：70 良好");
CD=getCourse(sc);
}else {
System.out.println("你的输入有误，重新输入！");
CD=getCourse(sc);
}
}
System.out.println("查询结束！");
sc.close();
}
public static String getCourse(Scanner kc) {
System.out.print("请输入你要查询的科目（输入退出结束）：");
String CD=kc.next();
return CD;
}
}
测试
题目3：输入1-3代表a/b/c
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
一个数：固定/输入/随机？
输入的一个数
一个程序，求1、2、3代表什么
举例：一个程序，1代表a，2代表b，3代表c
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，求1、2、3代表什么
(3).明确数据
输入
1/2/3
输出
a/b/c
提示语
输入
请输入1-3中的一个数字
运算
/
输出
这个数字代表：
(4).明确动作
输入
Scanner
运算
求1/2/3代表什么
输出
println/print?
(5).重述需求
用一个Console程序，输入1/2/3，输出这个数字代表a/b/c
1代表a/2代表b/3代表c
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出提示语
任务2：输入读入
任务3：运算（判断条件）
任务4：输出这个数字代表：a
任务5：输出提示语
任务6：输入读入
任务7：运算（判断条件）
任务8：输出这个数字代表：b
任务9：输出提示语
任务10：输入读入
任务11：运算（判断条件）
任务12：输出这个数字代表:c
3.实现（任务拆分的结果）
任务1：输出提示语
步骤
思维过程
实现
找动作
print/println
找数据
字符串
“请输入1-3中的一个数字：”
实现
动作+数据
System.out.print("请输入1-3中的一个数字：");
任务2：输入读入
步骤
思维过程
实现
找动作
输入的值
Scanner
找数据
类型：int
名字：um
int um
实现
动作+数据
int um=sc.nextInt();
任务3：运算（判断条件）
步骤
思维过程
实现
找动作
um=?
switch
找数据
1
case 1:
实现
动作+数据
Switch(um){
case 1:
}
任务4：输出这个数字代表：a
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“这个数字代表：b”
实现
动作+数据
System.out.println("这个数字代表：a");
…………
有重复，用循环（for）
四要素：
1.初始化：System.out.print("请输入1-3中的一个数字："),String um=sc.nextInt();
2.循环条件：um >=1&& um<=3;
3.循环体：switch(um){}
4.迭代：System.out.print("请输入1-3中的一个数字："),um=sc.nextInt();
public class R03If{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int um=0;
for(System.out.print("请输入1-3中的一个数字："),um=sc.nextInt();um>=1 && um<=3;
System.out.print("请输入1-3中的一个数字："),um=sc.nextInt()) {
switch(um) {
case 1:
System.out.println("这个数字代表：a");
break;
case 2:
System.out.println("这个数字代表：b");
break;
case 3:
System.out.println("这个数字代表 :c");
break;
}
}
System.out.println("输入错误！");
sc.close();
}
}
4.测试
题目4：比较
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
三个数：固定/输入/随机？
输入的三个数
一个程序，输入三个数，比较大小
举例：30>20>10
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输入三个数，比较大小
(3).明确数据
输入
三个整数
输出
从大到小
提示语
输入
请输入相同位数的三个整数：
运算
/
输出
/
(4).明确动作
输入
Scanner
运算
大到小排序
输出
Println/print?
(5).重述需求
用一个Console程序，输入三个数，比较大小
30>20>10
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出提示语
任务2：输入读入
任务3：运算（判断条件）
任务4：输出大到小的排序
任务5：输出提示语
任务6：输入读入
任务7：运算（判断条件）
任务8：输出大到小的排序
…………
任务x：输出提示语
任务x：输入读入
任务x：运算（判断条件）
任务x：输出大到小的排序
3.实现（任务拆分的结果）
任务1：提示输入语
步骤
思维过程
实现
找动作
print/println
找数据
字符串
“请输入相同位数的三个整数：”
实现
动作+数据
System.out.print("请输入相同位数的三个整数：");
任务2：输入读入
步骤
思维过程
实现
找动作
输入的值
Scanner
找数据
类型：int
名字:a b c
int a
int b
int c
实现
动作+数据
int a=sc.nextInt();
int b=sc.nextInt();
Int c=sc.nextInt();
任务3：运算（判断条件）
步骤
思维过程
实现
找动作
比较大小
if
找数据
a=30 b=20 c=10
a>b>c
实现
动作+数据
If(a>b>c){
}
任务4：输出大到小的排序
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串+int
a+">"+b+">"+c
实现
动作+数据
System.out.println(a+">"+b+">"+c);
…………
有重复，用循环（do...while）
四要素：
1.初始化：System.out.print("请输入相同位数的三个整数：");
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
循环体：if(){}else{}
迭代：System.out.print("请输入相同位数的三个整数：");
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
循环条件：a!=b && b!=c && c!=a
public class R04If {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入相同位数的三个整数：");
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
do {
if(a>b) {
if(a>c && b>c) {
System.out.println(a+">"+b+">"+c);
System.out.print("请输入相同位数的三个整数：");
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
}else {
System.out.println(c+">"+a+">"+b);
System.out.print("请输入相同位数的三个整数：");
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
}
}else {
if(b>c) {
System.out.println(b+">"+a+">"+c);
System.out.print("请输入相同位数的三个整数：");
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
}else {
System.out.println(c+">"+b+">"+a);
System.out.print("请输入相同位数的三个整数：");
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
}
}
}while(a!=b && b!=c && c!=a);
System.out.println("错误！");
sc.close();
}
}
4.测试
题目5：
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
班级：固定/输入/随机？
输入的班级名
一个程序，输入班级查询班级最高分
举例：输入一班，输出一班的高分是：567
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输入班级查询班级最高分
(3).明确数据
输入
班级名称
输出
班级最高分
提示语
输入
请输入班级名称（输入退出结束）：
运算
/
输出
一班的最高分是：
(4).明确动作
输入
Scanner
运算
求班级最高分
输出
Println/print?
(5).重述需求
用一个Console程序，输入班级名称查询班级最高分
一班的最高分是：
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出欢迎语
任务2：输出提示语
任务3：输入读入
任务4：运算（判断条件）
任务5：输出一班的最高分是：567
任务6：输出提示语
任务7：输入读入
任务8：运算（判断条件）
任务9：输出二班的最高分是：493
…………
任务x：输出提示语
任务x：输入读入
任务x：运算（判断条件）
任务x：输出xx
3.实现（任务拆分的结果）
任务1：输出欢迎语
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“欢迎使用查询系统”
实现
动作+数据
System.out.print("欢迎使用查询系统");
任务2：输出提示语
步骤
思维过程
实现
找动作
print/println
找数据
字符串
“请输入班级名称（输入退出结束）：”
实现
动作+数据
System.out.print("请输入班级名称（输入退出结束）：");
任务3：输入读入
步骤
思维过程
实现
找动作
输入值？
Scanner
找数据
类型：字符串
名字：bj
String bj
实现
动作+数据
String bj=sc.next();
任务4：运算（判断条件）
步骤
思维过程
实现
找动作
bj=?
if
找数据
一班
bj.contentEquals("一班")
实现
动作+数据
if(bj.contentEquals("一班"))
任务5：输出一班的最高分是：567
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“一班的最高分是：567”
实现
动作+数据
System.out.println("一班的最高分是：567");
…………
有重复，用循环（while）
四要素：
1.初始化：System.out.print("请输入高一班级名称（输入退出结束）：");
String bj=sc.next();
循环条件：bj.contentEquals("退出")==false
循环体：if(){}else{}
迭代：System.out.print("请输入班级名称（输入退出结束）：");
bj=sc.next();
public class R05If {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("欢迎使用查询系统");
String bj=getClass(sc);
while(bj.contentEquals("退出")==false) {
if(bj.contentEquals("一班")) {
System.out.println("一班的最高分是：567");
bj=getClass(sc);
}
else if(bj.contentEquals("二班")) {
System.out.println("二班的最高分是：493");
bj=getClass(sc);
}
else if(bj.contentEquals("三班")) {
System.out.println("三班的最高分是：546");
bj=getClass(sc);
}
else if(bj.contentEquals("四班")) {
System.out.println("四班的最高分是：533");
bj=getClass(sc);
}else if(bj.contentEquals("五班")) {
System.out.println("五班的最高分是：413");
bj=getClass(sc);
}else {
System.out.println("输入错误！重新输入");
bj=getClass(sc);
}}
System.out.println("查询结束！");
sc.close();
}
public static String getClass(Scanner sc) {
System.out.print("请输入班级名称（输入退出结束）：");
String bj=sc.next();
return bj;
}
}
4.测试
题目6：输出9 9乘法表
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
乘法表
一个程序，输出9*9乘法表
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输出9*9乘法表
(3).明确数据
输入
/
输出
9*9乘法表
提示语
输入
/
运算
/
输出
/
(4).明确动作
输入
/
运算
9*9乘法表
输出
Println/print?
(5).重述需求
用一个Console程序，输出9*9乘法表
1*1=1 ……
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：定义两个值
任务2：运算（判断条件）
任务3：输出1*1=1
任务4：定义两个值
任务5：运算（判断条件）
任务6：输出1*2=2
…………
任务x：定义两个值
任务x：运算（判断条件）
任务x：输出xxx
3.实现（任务拆分的结果）
任务1：定义两个值
步骤
思维过程
实现
找动作
类型：整数/字符串
int
找数据
1
x=1
y=1
实现
动作+数据
int x=1
Int y=1
任务2：运算（判断条件）
步骤
思维过程
实现
找动作
x? y?
If,>=
找数据
x=1 y=1
x<=9 && y<=x
实现
动作+数据
if(x<=9 && y<=x)
任务3：输出1*1=1
步骤
思维过程
实现
找动作
println/print
找数据
整数+字符串
y+"*"+x+"="+x*y+" "
实现
动作+数据
System.out.print(y+"*"+x+"="+x*y+" ");
…………
有重复，用循环（for）
四要素：
1：初始化：int x=1;int y=1;
循环条件：x<=9;y<=x;
循环体：System.out.print(y+"*"+x+"="+x*y+" ");System.out.println();
迭代：x++;y++;
public class R06If {
public static void main(String[] args) {
for(int x=1;x<=9;x++) {
for(int y=1;y<=x;y++) {
System.out.print(y+"*"+x+"="+x*y+"\t");
}
System.out.println();
}
}
}
4.测试
题目7：
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
一个数：固定/输入/随机？
一个输入的值
一个程序，输入课程码，查询课程名称
举例：一个程序，输入01，输出计算机应用基础
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输入课程码，查询课程名称
(3).明确数据
输入
课程码
输出
课程名称
提示语
输入
请输入课程码：（输入000退出）
运算
/
输出
/
(4).明确动作
输入
Scanner
运算
求课程名称
输出
Println/print?
(5).重述需求
用一个Console程序，输入课程码，查询课程名称
计算机应用程序
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出欢迎语
任务2：输出提示语
任务3：输入读入
任务4：运算（判断条件）
任务5：输出课程名称
任务6：输出提示语
任务7：输入读入
任务8：运算（判断条件）
任务9：输出课程名称
…………
任务x：输出提示语
任务x：输入读入
任务x：运算（判断条件）
任务x：输出xxx
3.实现（任务拆分的结果）
任务1：输出欢迎语
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“欢迎使用课程查询系统”
实现
动作+数据
System.out.println("欢迎使用课程查询系统");
任务2：输出提示语
步骤
思维过程
实现
找动作
print/println
找数据
字符串
“请输入课程码（输入000退出）：”
实现
动作+数据
System.out.print("请输入课程码（输入000退出）：");
任务3：输入读入
步骤
思维过程
实现
找动作
输入值？
Scanner
找数据
类型：整数
名字：kech
int kech
实现
动作+数据
int kech=sc.nextInt();
任务4：运算（判断条件）
步骤
思维过程
实现
找动作
kech=?
if
找数据
01
kech==01
实现
动作+数据
If(kech==01){
}
任务5：输出课程名称
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“计算机应用基础”
实现
动作+数据
System.out.println("计算机应用基础");
…………
有重复，用循环（do...whlie）
四要素：
1.初始化：System.out.print("请输入课程码（输入000退出）：");
int kech=dm.nextInt();
循环体：if(){}else{}
迭代：System.out.print("请输入课程码（输入000退出）：");
kech=dm.nextInt();
循环条件：kech!=000
public class R07If{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("欢迎使用课程查询系统");
int kech=getNum(sc);
do{
if(kech==01) {
System.out.println("计算机应用基础");
kech=getNum(sc);
}
else if(kech==02) {
System.out.println("计算机网络基础");
kech=getNum(sc);
}
else if(kech==03) {
System.out.println("程序设计基础");
kech=getNum(sc);
}
else if(kech==04) {
System.out.println("英语应用能力");
kech=getNum(sc);
}else if(kech==05) {
System.out.println("数学建模");
kech=getNum(sc);
}else {
System.out.println("输入错误！重新输入");
kech=getNum(sc);
}
}while(kech!=000) ;
System.out.println("查询结束！");
sc.close();
}
public static int getNum(Scanner dm) {
System.out.print("请输入课程码（输入000退出）：");
int kech=dm.nextInt();
return kech;
}
}
4.测试
题目8：猜数游戏
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
一个数：固定/输入/随机？
输入的一个值
一个程序，猜0~99中的任意一个数
举例：一个程序，输入1，输出对不起你猜小了...
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，猜0~99中的任意一个数
(3).明确数据
输入
0~99中任意一个数
输出
猜数结果
提示语
输入
请输入一个0~99之间的数：
运算
/
输出
猜数结果
(4).明确动作
输入
Scanner
运算
求猜数结果
输出
Println/print?
(5).重述需求
用一个Console程序，猜0~99中的任意一个数
/
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：定义两个值
任务2：输出欢迎语
任务3：输出提示语
任务4：输入读入
任务5：运算（比较）
任务:6：输出猜数结果
任务7：输出提示语
任务8：输入读入
任务9：运算（比较）
任务:10：输出猜数结果
…………
任务x：输出提示语
任务x：输入读入
任务x：运算（比较）
任务:x：输出猜数结果
3.实现（任务拆分的结果）
任务1：定义两个值
步骤
思维过程
实现
找动作
类型？
int,*
找数据
名字+值
cs=0
sjs=(int)(Math.random()*100)
实现
动作+数据
int cs=0
int sjs=(int)(Math.random()
*100)
任务2：输出欢迎语
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“欢迎来到猜字游戏”
实现
动作+数据
System.out.println("欢迎来到猜字游戏");
任务3：输出提示语
步骤
思维过程
实现
找动作
println/print
找数据
字符串
"请输入一个0~99之间的数："
实现
动作+数据
System.out.print("请输入一个0~99之间的数：");
任务4：输入读入
步骤
思维过程
实现
找动作
输入值？
Scanner
找数据
类型：int
名字：sr
int sr
实现
动作+数据
int sr=sc.nextInt();cs++;
任务5：运算（比较）
步骤
思维过程
实现
找动作
sr=?
if
找数据
sr sjs cs
sr==sjs cs==1
实现
动作+数据
if(sr==sjs){
if(cs==1) {
}}
任务:6：输出猜数结果
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串+变量
"你太棒了！用了"+cs+"次，就猜对了"
实现
动作+数据
System.out.println("你太棒了！用了"+cs+"次，就猜对了");
…………
有重复，用循环（do...whlie）
四要素：
初始化：System.out.println("请输入一个0~99之间的数：");
int sr=sc.nextInt();cs++;
循环体：if(){}else{}
迭代：sr=sc.nextInt();cs++;
循环条件：cs<20
public class R08If {
public static void main(String[] args) {
int cs=0;
int sjs=(int)(Math.random()*100);
Scanner sc=new Scanner(System.in);
System.out.println("欢迎来到猜字游戏");
System.out.println("请输入一个0~99之间的数：");
do {
int sr=sc.nextInt();cs++;
if(sr==sjs) {
if(cs==1) {
System.out.println("你太棒了！用了"+cs+"次，就猜对了");
break;
}
if(cs<=9&&cs>=2) {
System.out.println("你真聪明！用了"+cs+"次，就猜对了");
break;
}
if(cs>=10) {
System.out.println("恭喜你！用了"+cs+"次猜对了");
break;
}
}else {
if(sr>sjs) {
System.out.println("对不起，你猜大了！");
}
else {
System.out.println("对不起，你猜小了！");
}
}
}while(cs<20);
System.out.println("欢迎下次再玩！");
sc.close();
}
}
4.测试
题目9：
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
一个数：固定/输入/随机？
输入的一个数
一个程序，输入年龄，查询门票价格
举例：输入60，输出门票免费，欢迎！
(2).程序运行平台
Web/App/Console/应用软件
一个Console程序，输入年龄，查询门票价格
(3).明确数据
输入
年龄
输出
门票价格
提示语
输入
请输入年龄（输入0退出系统）：
运算
/
输出
门票价格
(4).明确动作
输入
Scanner
运算
求门票价格
输出
Println/print?
(5).重述需求
用一个Console程序，输入年龄，查询门票价格
输入60，输出门票免费，欢迎！
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：输出欢迎语
任务2：输出提示语
任务3：输入读入
任务4：运算（判断条件）
任务5：输出门票价格
任务6：输出提示语
任务7：输入读入
任务8：运算（判断条件）
任务9：输出门票价格
…………
任务x：输出提示语
任务x：输入读入
任务x：运算（判断条件）
任务x：输出门票价格
3.实现（任务拆分的结果）
任务1：输出欢迎语
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“欢迎进入门票查询系统”
实现
动作+数据
System.out.println("欢迎进入门票查询系统");
任务2：输出提示语
步骤
思维过程
实现
找动作
print/println
找数据
字符串
“请输入年龄（输入0退出系统）：”
实现
动作+数据
System.out.print(“请输入年龄（输入0退出系统）：”);
任务3：输入读入
步骤
思维过程
实现
找动作
输入值？
Scanner
找数据
类型：int
名字：nl
int nl
实现
动作+数据
int nl = sc.nextInt();
任务4：运算（判断条件）
步骤
思维过程
实现
找动作
nl=?
if
找数据
60~100
nl>=60&&nl<=100
实现
动作+数据
if(nl>=60&&nl<=100)
任务5：输出门票价格
步骤
思维过程
实现
找动作
print/println
println
找数据
字符串
“门票免费，欢迎！”
实现
动作+数据
System.out.println("门票免费，欢迎！");
…………
有重复，用循环（while）
四要素：
1.初始化：System.out.print("请输入年龄（输入0退出系统）：");
int nl = sc.nextInt();
循环条件：nl!=0
循环体：if(){}
迭代：System.out.print("请输入年龄（输入0退出系统）：");
nl = sc.nextInt();
public class R09If{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("欢迎进入门票查询系统");
int nl = getNum(sc);
while(nl!=00){
if(nl>=60&&nl<=100) {
System.out.println("门票免费，欢迎！");
nl = getNum(sc);
}
if(nl>=25&&nl<=59) {
System.out.println("需购买全票，欢迎！");
nl = getNum(sc);
}
if(nl>=9&&nl<=20) {
System.out.println("学生/儿童需购买半票，欢迎！");
nl = getNum(sc);
}
if(nl>=1&&nl<=8) {
System.out.println("无需购票，欢迎！");
nl = getNum(sc);
}
}
System.out.println("退出查询！");
}
public static int getNum(Scanner ff) {
System.out.print("请输入年龄（输入0退出系统）：");
int nl = ff.nextInt();
return nl;
}
}
4.测试
题目10：
1.明确需求（沟通过程中，将不确定变成选择）
步骤
思考步骤
重述需求并举例
(1)以人的思维找答案(把人看作机器)
计算
一个程序，计算球第10次落地经过多少米，反弹多高
(2).程序运行平台
Web/App/Console/应用软件
输入一个数，第10次落地经过多少米，反弹多高
(3).明确数据
输入
/
输出
第10次落地经过？米，反弹？高
提示语
输入
/
运算
/
输出
第10次落地经过？米，反弹？高
(4).明确动作
输入
/
运算
第10次落地经过多少米，反弹多高
输出
Println/print?
(5).重述需求
用一个Console程序，计算球第10次落地经过多少米，反弹多高
/
2.任务拆分（实现过程，从上到下。数据->运算->输出->）
任务1：定义两个值
任务2：运算（需计算10次，用循环，for）
任务3：输出球第10次落地经过多少米，反弹多高
3.实现（任务拆分的结果）
任务1：定义两个值
步骤
思维过程
实现
找动作
整数/字符串/浮点数
double
找数据
名字+值
gd=100 mi=0
实现
动作+数据
double gd=100;
double mi=0；
任务2：运算（需计算10次，用循环，for）
循环四要素
1.初始化
2.循环条件
3.循环体
4.迭代
int gd=0;
gd<=10;
gd=gd/2;
mi+=gd;
gd++
任务3：输出球第10次落地经过多少米，反弹多高
步骤
思维过程
实现
找动作
println/print
println
找数据
字符串+变量
"第10次经过"+m+"米"
"第10次反弹"+gd+"高"
实现
动作+数据
System.out.println("第10次经过"+m+"米");
System.out.println("第10次反弹"+g+"高");
public class R10If {
public static void main(String[] args) {
double gd=100;
double mi=0;
for(int gd=0;gd<=10;gd++) {
gd=gd/2;
mi+=gd;
}
System.out.println(mi);
System.out.println(gd);
}
}
4.测试