中山大学南方学院

电气与计算机工程学院

课程名称： 面向对象程序设计

实验题目： 作业1

2022年3月10日

附：实验报告

专业： 计算机科学与技术 年级： 21级 完成日期： 2022年3月10日星期四

学号： 2120110137 姓名： 徐海超 成绩：

目录

附：实验报告 2

1 实验目的 2

2 实验原理 2

3 实验过程 2

1 打印校歌（第一周作业） 2

2 斐波那契数列（第一周作业） 3

3 练习题1：（学习通ppt） 3

4 练习题2：（学习通ppt） 4

5 练习题3：（学习通ppt） 5

6 练习题4：（学习通ppt） 6

7 练习题5：（学习通ppt） 7

8 练习题6：（学习通ppt） 8

9 计算阶乘（学习通ppt） 9

10 输出1~200以内的质数（学习通ppt） 9

11 用循环打印九九乘法表（学习通ppt） 10

12 输入所有水仙花数 11

13 猜数字游戏 11

14 算术运算练习器 12

4 实验总结和体会 15

实验目的

1．掌握Java语言的标识符和保留字,各简单数据类型变量以及有逻辑量意义数据的表示方法以及表示条件的表达式的类型。

2．掌握Java语言中具各种运算符表达式的基本知识。

3．熟练掌握使用if语句进行单分支结构和双分支结构程序设计的基本方法。

4．熟练掌握使用if语句的嵌套及switch语句进行多分支结构程序设计的基本方法。

实验原理

1.使用Scanner类，引入import java.util.Scanner包

2.使用Math类，引用random()方法来生成随机数

实验过程

打印校歌（第一周作业）

1. public class NanfangCollegelSong {  
2.     public static void main(String[] args) {  
3.         System.out.println("广州南方学院校歌");  
4.         System.out.println("南风薰兮，珠水流长。" + "\n" + "依山带河，绿树红墙。" + "\n" +  
5.                             "寸草春晖，师恩不忘。" + "\n" + "鸢飞鱼跃，活力飞扬。" + "\n" +  
6.                             "厚德砥行，立身四方。" + "\n" + "勤于忏思，愈挫愈强。" + "\n"+  
7.                             "追求真理，拼搏向上。" + "\n" + "德才兼备，为国栋梁。");  
8.     }  
9. }  

斐波那契数列（第一周作业）

1. import java.util.Scanner;  
2. public class Feibonaqie {  
3.     public static void main(String[] args) {  
4.         // 1 1 2 3 5 8 13 21 ……  
5.         //first + second = third  
6.         //   1  +    1   =   2  
7.         //   1  +    2   =   3  
8.         //   2  +    3   =   5  
9.         //   3  +    5   =   8  
10.         //   5  +    8   =   13  
11.         //  ………………………………………………  
12.         //  
13.         Scanner myScanner = new Scanner(System.in);  
14.         int input = myScanner.nextInt();  
15.         int first = 1;  
16.         int second = 1;  
17.         int third = 0;  
18.         System.out.println("你想得到几位斐波那契数字");  
19.         System.out.print(first + "\n" + second + "\n");  
20.         for (int i = 2; i <= input; i++) {  
21.            third = first + second;  
22.            first = second;  
23.            second = third;  
24.             System.out.println(third);  
25.         }  
26.   
27.   
28.     }  
29. }  

练习题1：（学习通ppt）

1.判断两个整型变量x1和x2的大小

2.判断字符变量ch的值是否为 ’A’

1. import java.util.Scanner;  
2. public class JudgmentInt {  
3.     public static void main(String[] args) {  
4.         Scanner myScanner = new Scanner(System.in);  
5.         int big = 0;  
6.         System.out.println("请输入x1：");  
7.         int x1 = myScanner.nextInt();  
8.         System.out.println("请输入x2：");  
9.         int x2 = myScanner.nextInt();  
10.         if(x1 > x2){  
11.             System.out.println("x1 > x2");  
12.         }  
13.         if(x1 < x2){  
14.             System.out.println("x1 < x2");  
15.         }  
16.         if(x1 == x2){  
17.             System.out.println("x1 = x2");  
18.         }  
19.   
20.     }  
21. } 
22. import java.util.Scanner;  
23. public class JudgmentChar {  
24.     public static void main(String[] args) {  
25.         Scanner myScanner = new Scanner(System.in);  
26.         int ch = myScanner.nextInt();  
27.         if(ch == 97){  
28.             System.out.println("ch的值是’A‘");  
29.         }  
30.     }  
31. }  
32.  

练习题2：（学习通ppt）

1.判断整型变量x在某个范围中，如0 <= x <= 100?

2.判断整型变量y不在某个范围中，如 y < 0或者y > 100

1. import java.util.Scanner;  
2. public class JudgmentX {  
3.     public static void main(String[] args) {  
4.         while(true) {  
5.             Scanner myScanner = new Scanner(System.in);  
6.             int x = myScanner.nextInt();  
7.             if (x >= 0 && x <= 100) {  
8.                 System.out.println("x 的值在 x >= 0 && x <= 100 范围中");  
9.             } else {  
10.                 System.out.println("x 的值不在 x >= 0 && x <= 100 范围中");  
11.             }  
12.         }  
13.     }  
14. }  
15. import java.util.Scanner;  
16. public class JudgmentY {  
17.     public static void main(String[] args) {  
18.         Scanner myScanner = new Scanner(System.in);  
19.         int y = myScanner.nextInt();  
20.         if (y >= 0 && y <= 100) {  
21.             System.out.println("y 的值在 y >= 0 && y <= 100 范围中");  
22.         } else {  
23.             System.out.println("y 的值不在 y >= 0 && y <= 100 范围中");  
24.         }  
25.     }  
26. }  

练习题3：（学习通ppt）

1获取两个整型变量x1和x2的较大值，并把该值赋值给x.

1. import java.util.Scanner;  
2. public class JudgmentX1X2 {  
3.     public static void main(String[] args) {  
4.         Scanner myScanner = new Scanner(System.in);  
5.         System.out.println("请输入x1：");  
6.         int x1 = myScanner.nextInt();  
7.         System.out.println("请输入x2：");  
8.         int x2 = myScanner.nextInt();  
9.         int max = Max(x1,x2);  
10.         System.out.println("最大是数字是" + max);  
11.     }  
12.     public static int Max(int x,int y) {  
13.         int result = 0;  
14.         if (x > y) {  
15.             result = x;  
16.         }else{  
17.             result = y;  
18.         }  
19.         return result;  
20.     }  
21. }  

练习题4：（学习通ppt）

1.获取三个整型变量x1、x2和x3的较大值，并把该值赋值给x。

2.循环输入10个整数。（我把2和3都合在一起）

3.循环输入10个整数，如果输入的整数为0，退出循环。

1. import java.util.Scanner;  
2. public class PanDuanDaXiao {  
3.     public static void main(String[] args) {  
4.         while (true) {  
5.             System.out.println("请输入三个数：");  
6.             Scanner myScanner = new Scanner(System.in);  
7.             int x1 = myScanner.nextInt();  
8.             int x2 = myScanner.nextInt();  
9.             int x3 = myScanner.nextInt();  
10.             int x = 0;  
11.             if (x1 > x2 && x1 > x3) {  
12.                 x = x1;  
13.                 System.out.println("x1最大此时x为" + x);  
14.                 break;  
15.             }  
16.             if (x2 > x1 && x2 > x3) {  
17.                 x = x2;  
18.                 System.out.println("x2最大此时x为" + x);  
19.                 break;  
20.             }  
21.             if (x3 > x1 && x3 > x2) {  
22.                 x = x3;  
23.                 System.out.println("x3最大此时x为" + x);  
24.                 break;  
25.             }  
26.         }  
27.   
28.     }  
29. }  
30. import java.util.Scanner;  
31. public class CycleNnumbers {  
32.     public static void main(String[] args) {  
33.         Scanner myScanner = new Scanner(System.in);  
34.         for (int i = 1; i <= 10; i++) {  
35.             int input = myScanner.nextInt();  
36.             if(input == 0){  
37.                 break;  
38.             }  
39.             System.out.println(input);  
40.         }  
41.     }  
42. }  

练习题5：（学习通ppt）

判断某学生的成绩x属于哪个等级: ‘A’, ‘B’, ‘C’, ‘D’, ‘E’.

1. import java.util.Scanner;  
2. public class StudentScoreJudgment {  
3.     public static void main(String[] args) {  
4.         Scanner myScanner = new Scanner(System.in);  
5.         while (true) {  
6.             int score = myScanner.nextInt();  
7.             int judgment = score / 10;  
8.             if (score >= 0 && score <= 100) {  
9.   
10.                 if (judgment == 10 || judgment == 9 || judgment == 8) {  
11.                     System.out.println("A");  
12.                 } else if (judgment == 7) {  
13.                     System.out.println("B");  
14.                 } else if (judgment == 6) {  
15.                     System.out.println("C");  
16.                 } else if (judgment == 5) {  
17.                     System.out.println("D");  
18.                 } else {  
19.                     System.out.println("E");  
20.                 }  
21.             }else{  
22.                 System.out.println("你的输出有误，请重新输入");  
23.             }  
24.         }  
25.     }  
26. }  

练习题6：（学习通ppt）

1. 循环判断学生的成绩x属于哪个等级: ‘A’, ‘B’, ‘C’, ‘D’, ‘E’.
2. import java.util.Scanner;  
3. public class StudentScoreSwitch {  
4.     public static void main(String[] args) {  
5.         Scanner myScanner = new Scanner(System.in);  
6.         while (true) {  
7.             int score = myScanner.nextInt();  
8.             int judgment = score / 10;  
9.             if (score >= 0 && score <= 100) {  
10.   
11.                 switch (judgment) {  
12.                     case 10:  
13.                     case 9:  
14.                     case 8:  
15.                         System.out.println("A");  
16.                         break;  
17.                     case 7:  
18.                         System.out.println("B");  
19.                         break;  
20.                     case 6:  
21.                         System.out.println("C");  
22.                         break;  
23.                     case 5:  
24.                         System.out.println("D");  
25.                         break;  
26.                     default:  
27.             /* 
28.                 case 4: 
29.                 case 3: 
30.                 case 2: 
31.                 case 1: 
32.                 case 0: 
33.  
34.              */  
35.                         System.out.println("E");  
36.                 }  
37.             }else{  
38.                 System.out.println("你的输出有误，请重新输入");  
39.             }  
40.             }  
41.         }  
42.     }  

计算阶乘（学习通ppt）

1！+2！+3！+… +10!

1. import java.util.Scanner;  
2. public class Factorial {  
3.     public static void main(String[] args) {  
4.         //计算阶乘  
5.         //1！+2！+3！+4！+…………+=?  
6.         //1+(1*2)+(1*2*3)+(1*2*3*4)+……+=  
7.   
8.         Scanner myScanner = new Scanner(System.in);  
9.         System.out.println("请输入要计算几位阶乘：");  
10.         int num = myScanner.nextInt();  
11.         int first = 0;  
12.         int sum = 0;  
13.         //保持最前面乘数为1  
14.         for (int i = 1; i <= num ; i++) {  
15.             first = 1;  
16.             //通过循环来不断更新乘数，覆盖原先的数  
17.             // 此时的循环次数不能大于第一次循环的次数  
18.             //每次循环截至后，又回到上面的循环，此时的first已更新  
19.             for (int j = 1; j <= i ; j++) {  
20.                 first = first * j;  
21.             }  
22.             //累加  
23.             sum = sum + first;  
24.         }  
25.         System.out.println(sum);  
26.     }  
27. }  

输出1~200以内的质数（学习通ppt）

质数：除了1和自身外再也找不到其它约数

1. import javax.rmi.ssl.SslRMIClientSocketFactory;  
2. import java.util.Scanner;  
3. public class PrimeNumber {  
4.     public static void main(String[] args) {  
5.         Scanner myScanner = new Scanner(System.in);  
6.         System.out.println("输出0到几内的质数");  
7.         int input = myScanner.nextInt();  
8.         //先准备第一重循环，来输出inpupt个数  
9.         for (int i = 2; i <= input; i++) {  
10.             //再用第二次循环依次输出1至input个数准备做除  
11.             int j = 2;  
12.             for (; j < i; j++) {  
13.                 //如果第一次循环中的数能够被第二次循环时整除，说明有可能是质数  
14.                 //为了记录当前所获得的值，停止循环，得到j  
15.                 //（被整除后，停止第二次循环，同时记录了第二次循环的值（j值的大小））  
16.                 if (i % j == 0) {  
17.                     break;  
18.                 }  
19.   
20.             }  
21.   
22.             //来到第二次判断，判断是否是真的质数  
23.             //判断方法：j必须是等于i  
24.             // 如果是小于的话，说明在这之前就已经被整除了，不是除了1和自身意外可以整除的数（再次之前被整除了）  
25.             if ( j == i) {  
26.                 System.out.println(i);  
27.             }  
28.         }  
29.   
30.   
31.   
32.     }  
33.   
34. }  

用循环打印九九乘法表（学习通ppt）

1. public class MultiplicationTable {  
2.     public static void main(String[] args){  
3.   
4.         for (int i = 1; i <= 9 ; i++) {  
5.             for (int j = 1; j <= 9 ; j++) {  
6.                 System.out.println(i + "*" + j + "=" + i*j);  
7.             }  
8.             System.out.print("");  
9.         }  
10.     }  
11. }  

输入所有水仙花数

1. import java.util.Scanner;  
2. public class NumberOfDaffodils {  
3.     public static void main(String[] args) {  
4.         Scanner myScanner = new Scanner(System.in);  
5.         while (true) {  
6.             System.out.println("请输入水仙花数");  
7.             int input = myScanner.nextInt();  
8.             int SingleDigit = input % 10;  
9.             int Ten = input / 10 % 10;  
10.             int Hundreds = input / 100 % 10;  
11.             if (SingleDigit * SingleDigit * SingleDigit + Ten * Ten * Ten + Hundreds * Hundreds * Hundreds == input) {  
12.                 System.out.println(input + "是水仙花数");  
13.             } else {  
14.                 System.out.println(input + "不是水仙花数");  
15.             }  
16.         }  
17.   
18.     }  
19.   
20. }  

猜数字游戏

1. import java.util.Scanner;  
2. public class NumberGuessingGame {  
3.     public static void main(String[] args) {  
4.         int count = 0;  
5.         while (true) {  
6.             System.out.println("请输入数字：");  
7.             Scanner myScanner = new Scanner(System.in);  
8.             int input = myScanner.nextInt();  
9.             int random = (int) (Math.random() * 10000);  
10.             if (input < random) {  
11.                 count++;  
12.                 System.out.println("太小了，再大一点！");  
13.             }else if (input > random) {  
14.                 count++;  
15.                 System.out.println("太大了，再小一点！");  
16.             }else if (input == random) {  
17.                     System.out.println("恭喜你猜对了！");  
18.                     break;  
19.                 }  
20.             if(count==10){  
21.                     System.out.println("你太笨了，下次再来吧！");  
22.                     break;  
23.                 }  
24.   
25.         }  
26.     }  
27. }  

算术运算练习器

1. import java.util.Scanner;  
2.   
3. public class ArithmeticExerciser {  
4.     public static void main(String[] args) {  
5.         //编写程序，实现一个简单的算术运算的练习器，程序运行时随机生成两个两位数，  
6.         //和一个运算符（+，-，*，/），并组成一个表达式输出出来  
7.         //然后读取用户的输入答案，如果输入答案正确，则输出祝贺信息  
8.         //若输入答案错误，则提示重来一次  
9.   
10.         //思路  
11.         //有用户输入部分，使用 java.util.Scanner类  
12.         //生成两个随机数进行计算，定义两个变量，使用Math.random()   由于只能随机输出0.1~1的随机数，故在后面*100 输出1~100内的整数  
13.         //因为计算中有 / 故使用double  
14.         //随机输出运算符，在网上搜了一圈，大多都是使用未学过的知识，我决定生成 随机数 加 条件判断 来随机输出运算符  
15.         //使用Math.random()   由于只能随机输出0.1~1的随机数，我只想取0~7之间的数字  
16.         //因为该题中 运算符只有四个 每个运算符后面都用两个数，例如如果随机数为0或1，则生成 +  
17.         //                                                 随机数为2或3，则生成 -  
18.         //                                                 随机数为4或5，则生成 *  
19.         //                                                 随机数为6或7，则生成 /  
20.         //故先Math.random()*10,输出0~10之间的数  
21.         //使用if(),只要>=7的数，剩下的不输出  
22.         //再嵌套switch()则可以随机生成运算符  
23.         //定义一个变量表示结果  
24.         //再使用if()来判断用是否输入错误  
25.         //因为要统计用户答题情况  
26.         //故定义两个变量来统计，放在判断答题对错的if内  
27.   
28.         //梳理  
29.         //因为可以一直答题和统计，使用while循环，嵌套在所有外面  
30.         //然后是if判断，这个来接收生成随机数为0~7的数  
31.         //接着是switch判断，随机生成运算符  
32.         //在switch中，用if判断用户是否输入正确  
33.         //switch中的其中一个语句块执行完后，break  
34.   
35.   
36.         //使用Scanner类，用于用户输入  
37.         Scanner myScanner = new Scanner(System.in);  
38.         //定义两个分别代表答题正确和错误的变量，用于统计答题情况  
39.         int good = 0;  
40.         int wrond = 0;  
41.   
42.         //while循环，不断生成新的四则运算题  
43.         while (true) {  
44.   
45.             //使用Math.random() ，定义operator，用于生成1~10之间的数  
46.             int operator = (int) (Math.random() * 10);  
47.             //使用if过滤掉大于7的数，只要0~7的数，才运行程序  
48.             if (operator <= 7) {  
49.   
50.                 //定义生成两个随机数  
51.                 double ran1 = (int) (Math.random() * 100);  
52.                 double ran2 = (int) (Math.random() * 100);  
53.                 //定义一个变量表示运算结果  
54.                 double result = 0;  
55.   
56.                 //使用switch，对刚刚0~7的数字进行分类，两个数字代表一个运算符  
57.                 switch (operator) {  
58.                     case 0:  
59.                     case 1:  
60.                         //在用户输入之前，先打印这道题  
61.                         System.out.println(ran1 + "+" + ran2 + "=");  
62.                         //让用户输入  
63.                         int input1 = myScanner.nextInt();  
64.                         //程序进行计算  
65.                         result = ran1 + ran2;  
66.                         //使用if来判断用户输入的是否正确  
67.                         if(input1 == result){  
68.                             System.out.println("恭喜你，答对了");  
69.                             //答对了，刚刚定义的正确的统计数+1  
70.                             good++;  
71.                             System.out.println(ran1 + "+" + ran2 + "=" +result);  
72.                         }else{  
73.                             System.out.println("你答错了，请重来一次！");  
74.                             //答错了，刚刚定义的错误的统计数+1  
75.                             wrond++;  
76.                             System.out.println(ran1 + "+" + ran2 + "=" +result);  
77.                         }  
78.                         //进行一个统计  
79.                         System.out.println("你目前共答对了"+good+"道题，答错了"+wrond+"道题,加油！");  
80.                         break;  
81.   
82.                     case 2:  
83.                     case 3:  
84.                         System.out.println(ran1 + "-" + ran2 + "=");  
85.                         int input2 = myScanner.nextInt();  
86.                         result = ran1 - ran2;  
87.                         if (input2 == result) {  
88.                             System.out.println("恭喜你，答对了");  
89.                             good++;  
90.                             System.out.println(ran1 + "-" + ran2 + "=" + result);  
91.                         } else {  
92.                             System.out.println("你答错了，请重来一次！");  
93.                             wrond++;  
94.                             System.out.println(ran1 + "-" + ran2 + "=" + result);  
95.                         }  
96.                         System.out.println("你目前共答对了"+good+"道题，答错了"+wrond+"道题，加油！");  
97.                         break;  
98.   
99.   
100.                     case 4:  
101.                     case 5:  
102.                         System.out.println(ran1 + "*" + ran2 + "=");  
103.                         int input3 = myScanner.nextInt();  
104.                         result = ran1 * ran2;  
105.                         if (input3 == result) {  
106.                             System.out.println("恭喜你，答对了");  
107.                             good++;  
108.                             System.out.println(ran1 + "*" + ran2 + "=" + result);  
109.                         } else {  
110.                             System.out.println("你答错了，请重来一次！");  
111.                             wrond++;  
112.                             System.out.println(ran1 + "*" + ran2 + "=" + result);  
113.                         }  
114.                         System.out.println("你目前共答对了"+good+"道题，答错了"+wrond+"道题，加油！");  
115.                         break;  
116.   
117.   
118.                     case 6:  
119.                     case 7:  
120.                         System.out.println(ran1 + "/" + ran2 + "=");  
121.                         int input4 = myScanner.nextInt();  
122.                         result = ran1 / ran2;  
123.                         if (input4 == result) {  
124.                             System.out.println("恭喜你，答对了");  
125.                             good++;  
126.                             System.out.println(ran1 + "/" + ran2 + "=" + result);  
127.                         } else {  
128.                             System.out.println("你答错了，请重来一次！");  
129.                             wrond++;  
130.                             System.out.println(ran1 + "/" + ran2 + "=" + result);  
131.                         }  
132.                         System.out.println("你目前共答对了"+good+"道题，答错了"+wrond+"道题，加油！");  
133.                         break;  
134.                 }  
135.   
136.             }  
137.   
138.         }  
139.     }  
140. }  

实验总结和体会

体会到编程的乐趣，继续努力，加油！