一、基础问答15题
1、【基本概念问答】
请问Java语言是跨平台的吗？JVM是跨平台的吗？为什么？
答：
Java语言是跨平台的，JVM是不跨平台的。
Java能跨平台正是以JVM不跨平台为代价的。
Java的跨平台性由JVM实现，即JVM用于保证java的跨平台的特性。
原理分析：
JVM是在机器和编译程序之间加入的一层抽象的虚拟机器，
这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。
编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由 解释器 来将虚拟机代码转换为特定系统的机器码执行。
在Java中，这种供虚拟机理解的代码叫做字节码（即Java源代码经过虚拟机编译器编译后产生的文件，扩展为.class的文件），它不面向任何特定的处理器，只面向虚拟机，使Java程序无须重新编译便可在多种不同的计算机上运行。
每一种平台的解释器是不同的，但是实现的虚拟机是相同的。
Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm（字节码由虚拟机解释执行）---->jvm中解释器（虚拟机将每一条要执行的字节码送给解释器）----->机器可执行的二进制机器码---->程序运行。
不配置环境变量可不可以命令行编译执行Java代码？
请尝试配置环境变量，达到在命令行（cmd）窗口输入 命令就能启动的效果。（效果截图）
答：
（1）path环境变量的配置：
path是配置Windows可执行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，
用于指定DOS窗口命令的路径。
告诉操作系统到哪里去找javac可执行程序配置。
① 永久配置方式：
JAVA_HOME=%安装路径%Javajdk
path=%JAVA_HOME%bin
② 临时配置方式：
set path=路径；
（2）classpath的配置:
classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的。
给jvm用，告诉jvm到哪里加载字节码文件配置。
如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；
如果指定了classpath，那么会在指定的目录下查找要运行的类文件。
（3）配置环境变量，达到在命令行（cmd）窗口输入wechat 命令就能启动 微信 的效果。:
注：因为 启动 涉及到账号 和 密码位数，故将 启动，改成启动 微信。两者操作 完全一样。
① 设置 Path 环境变量之前：
② 设置 Path 环境变量之后
在Path变量中添加wechat启动程序的路径，即可以在任意目录下，通过命令行执行。
（要求记事本完成，该题目提交 Helloworld程序的代码及命令行cmd运行截图即可）
答：
再将0b0（二进制）、0345（八进制）、0Xef（十六进制） 转换为十进制。
注：该题无需写代码，在纸上手算一下过程，拍照附在文档中提交作业。
答：
（1）相应知识点：
十进制数：在数字的右下角标注10或D。默认是十进制。
进制之间的转换：
① 二进制 --> 十进制
将二进制数写成按权展开式，并将式中各乘积项的积相加，即得对应十进制数。
② 十进制 --> 二进制 / 八进制等
分为整数部分转换和小数部分转换
在十进制的小数部分转换中，有时连续乘以2不一定能使小数部分等于0，这说明该十进制小数不能用有限位二进制小数表示。这时，只要取足够多的位数，使其误差达到所要求的精度就可以了。
示例：十进制转换成二进制
③ 二进制 --> 八进制
④ 八进制 --> 二进制
⑤ 二进制 --> 十六进制
⑥ 十六进制 --> 二进制
（2）67转换为二进制、八进制、十六进制。
① (67)10 转换成二进制
67 / 2 = 33 (a0 = 1) 最低整数位
33 / 2 = 16 (a1 = 1)
16 / 2 = 8 (a2 = 0)
8 / 2 = 4 (a3 = 0)
4 / 2 = 2 (a4 = 0)
2 / 2 = 1 (a5 = 0)
1 / 2 = 0 (a6 = 1) 最高整数位
故 (67)10 = ()2
② (67)10 转换成八进制
67 / 8 = 8 (a0 = 3) 最低整数位
8 / 8 = 1 (a1 = 0)
1 / 2 = 0 (a2 = 1) 最高整数位
故 (67)10 = (103)O
③ (67)10 转换成十六进制
67 / 16 = 4 (a0 = 3) 最低整数位
4 / 16 = 0 (a1 = 4) 最高整数位
故 (67)10 = (43)H
（3）将0b0（二进制）、0345（八进制）、0Xef（十六进制） 转换为十进制。
(0)B = 0 × 26 + 1 × 25 + 0 × 24 + 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20 = (37)B
(0345)O = 0 × 83 + 3 × 82 + 4 × 81 + 5 × 80 = (229)B
(ef)H = 14 × 161 + 15 × 160 = (239)B
已知补码0和，求它们的原码。（要求如题4）
注：进制和原码等概念属于计算机编程基础知识，建议了解并熟悉它。
答：
（1）相应知识点：
正数的原码 = 补码
负数原码 --> 补码：符号位不变，其余位取反，末位 + 1。
补码的补码（补码求补）= 补码对应的原码。
（2）练习
正数原码 0 = 补码
负数原码 补码是 （符号位不变，其余位取反，末位 + 1）
正数补码 0 = 原码
负数补码 原码是 （符号位不变，其余位取反，末位 + 1）
如果不能为什么呢？怎样让它通过编译呢？
（作为简答题说明一下即可）
答：
1）编译结果如下：
编译不通过。
2）编译不通过的原因如下：
①相应知识点
精度从高到低 double float long int short(char) byte
自动类型转换（隐式转换）：低精度–>高精度
强制类型转换（显示转换）： 高精度–>低精度(精度会下降)
②具体原因：
byte的表示范围是 -128~127，300超出byte表示范围，故无法完成赋值。
3）通过编译的解决方法：
进行强制类型转换
byte b = (byte)300； // 此时，输出的b为44
或者将变量b定义成int类型，或者将byte类型的b变量的赋值，改为 -128~127内的一个数。
7、【算术运算符】 java基础测试题题库
以int a = 0; 语句为前提， a = a + 0.1; 和a += 0.1; 两条语句都能正常运行吗？两者有什么区别？
（仍作为简答题回答）
答：
a+=b 和 a=a+b 的区别：
① a += b执行过程：先计算出a的值，然后用一个temp对象存储，之后和b进行相加，然后将值赋值给a引用。
+= 如果两边的操作数的精度不一样时会自动向低转化。
② a = a+b 执行过程：先计算 a + b，然后再赋值给a引用，给a引用的时候如果 引用a 有计算过程，则会再次计算。
a = a+b则不会自动转化，需要手动进行强制类型转化。
练习：
int a = 0; a = a + 0.1;（x）与 int a = 0; a += 0.1;（√）
对于 int a = 0; a = a + 0.1;由于 0.1 是 double 类型，因此 a + 0.1 运算结果也是 double 型，需要强制转换类型才能赋值给 int 型。
而 int a = 0; a += 0.1; 可以正确编译，因为 a += 0.1; 相当于 a = (int(a + 0.1);其中有隐含的强制类型转换。
这两条语句定义的浮点数a和b，请问它们相等嘛？为什么？
答：不相等。
float 是32位的单精度，double 是64位的双精度。
浮点数都是近似值，位数越多，表示的就越精确。
（简答题，考虑位运算符）
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个数：”);
int num = input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
运行结果：
答：
（1） “+” 运算符：
① 可表示加法运算；
② 可表示正数；
③ 可表示字符串拼接；
操作数1 + 操作数2 + … 在多个操作数中，只要有一个是字符串，"+“操作执行的就是字符串拼接。
举例：
System.out.println(“hello” + ‘a’ + 1); // helloa1
System.out.println(‘a’ + 1 + “hello”); // 98hello （‘a’的ascii码是97）
System.out.println(“5+5=”+5+5); //5+5=55
System.out.println(5+5+”=5+5"); //10=5+5
（2）练习答案：
对于一个变量a，给出一个表达式a + “hello” ，结果的数据类型是 字符串类型，输出的是变量a的值和hello组成的字符串。
int a = 10;
int b;
System.out.println(b = a + 10);
1
2
3
答：
输出结果是 20
b = a + 10;表示将a + 10 的结果赋值给b，于是b的结果是20 ，这个表达式的值是赋值后b的值。
请在这道题下面附上符合语法的标识符命名规范。
1） 1myName ×
2.）你好% ×
3.）My_name √
4.）Points √
5.）$point √
6.）_sys_ta √
7） OK123 √
8）_23b# ×
9）3 √
10）main √
11）class ×
答：
标识符的命名规则：
由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，首字符不能是数字。
大小写敏感。
不能是关键字。
下列标识符的字符串组成，都是符合语法要求的，请问哪些是符合约定俗成命名规范的？哪些不符合？
请在这道题下面附上符合约定俗成规范的Java标识符命名规范。（根据不同语法结构给出）
类名：
1）demo ×
2）test ×
3） Student √
4） Student_ ×
5） program1 ×
6） MYDemo ×
7） myDemo ×
8） XueSheng √
变量名：
9）age √
10） nianLing √
11）myName √
12）_name ×
13）Variable ×
包名：
14）com.baidu √
15）Com.Baidu ×
16）bao.ceshi ×
注：标识符命名规范相当重要。
答：
命名规则：
（1）包：
包类似于操作系统中以文件夹的形式组织文件。
在JAVA语言中，以包来组织JAVA中的类，不同包下可以包含同名的类名。
为了包名的唯一，通常以域名反转的方式来命名包，例：com.baidu.www。
多级包： 以域名（是唯一的）反转的方式来命名包，单词全部小写。
单极包： 一个全部小写的单词。如 test
（2）类和接口:
单个：首字母大写，其余字母全部小写。如 Student
多个单词：多个单词的首字母均大写，其余字母全部小写 。如：JavaBasic 、MaxAge
（3）变量和方法：
单个：所有字母小写。 如：value
多个单词：第一个单词首字母小写，从第二个开始，每个单词首字母大写。 如：intValue
（4）常量：
所有单词字母都大写。如MAX
多个单词：单词之间用_来分割，如MAX_AGE
具体的Java开发规范文档：阿里巴巴Java开发手册（嵩山版）
注释会对程序的运行产生影响嘛？
注释的内容会存在于Java代码编译执行的哪一部分？
答：
（1）知识点
单行注释
格式：// 注释文字
多行注释
格式：/* 注释文字 */
文档注释
格式：/ 注释文字 */
可用来生成网页格式的帮助文档。
多行和文档注释都不能嵌套使用。
（2）练习答案
① 注释的作用：对程序语言进行说明，有助于开发者和用户之间的交流，方便理解程序。
② 注释会对程序的运行产生影响嘛？
③ 注释的内容会存在于Java代码编译执行的哪一部分？
需要按几个步骤进行？请写出步骤。
答：
① 创建 扫描器 对象，获取用户的输入
② 读取数据，读取数据的方法见下面的详细知识点
③ 关闭
下面以int型数组为例：
public static void main(String[] args) {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
详细知识点：
hasNest（）：判断下一个输入是否是字符串
next（）：用于读取String字符串数组，以空格划分（只读取输入直到空格），在读取后将光标指向本行
nextLine()：用于读取String字符串数组，读取包括单词之间的空格和除回车以外的所有符号，在读取后将光标指向下一行
小技巧：
既要读取普通数据，又要读取nextLine（读取一行字符串）：使用两个Scanner对象
举例如下：
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Scanner strInput = new Scanner(System.in);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行结果：
二、编程基础30题
1、【回文数】
打印5位数中的所有回文数，每行打印10个数。最后统计一下一共有多少个5位回文数。
注：回文数即正反读都是一个数，5位数的话，只要个位与万位相同，十位与千位相同就是一个回文数。
public class JavaBasic01 {
public static void main(String[] args) {
/*
//打印所有的5位回文数 ≠ 判断一个数是否是回文数
*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果：
1）输出所有的5位回文数
中间部分省略
2）判断是否是回文数
（考虑使用switch）
public class JavaBasic02 {
public static void main(String[] args) {
System.out.print(“请输入星期一、星期二、星期三、星期四。。。代表的数字:”);
Scanner input = new Scanner(System.in);
int num = input.nextInt();
switch (num){
case 1:
System.out.print(“星期一”);
break;
case 2:
System.out.print(“星期二”);
break;
case 3:
System.out.print(“星期三”);
break;
case 4:
System.out.print(“星期四”);
break;
case 5:
System.out.print(“星期五”);
break;
case 6:
System.out.print(“星期六”);
break;
case 7:
System.out.print(“星期七”);
break;
default:
System.out.print(“您输入的数字有误！”);
}
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
运行结果：
3、【if多分支-求成绩】
键盘录入一个学生成绩（用int表示），自动输出该同学的成绩评级。
学生的分数取值范围[0,100]
分数大于等于90的，评级"优秀"；
分数大于等于80，小于90的，评级"良好"；
分数大于等于70，小于80的，评级"中等"；
分数大于等于60，小于70的，评级"及格"；
分数小于60的，评级"不及格"；
public class JavaBasic03 {
public static void main(String[] args) {
System.out.print(“请输入该学生的成绩:”);
Scanner input = new Scanner(System.in);
double score = input.nextDouble();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
运行结果：
注：所谓的"水仙花数"是指一个三位数，其各位数字的立方和等于该数本身。例如153是一个"水仙花数"，因为153 = 1的三次方 + 5的三次方 + 3的三次方。（使用for循环遍历一下就出来了）
public class JavaBasic04 {
public static void main(String[] args) {
//打印所有的三位水仙花数 ≠ 判断一个数是否是水仙花数
//与 JavaBasic01 打印所有的五位回文数相类似
for (int Dig_1 = 0;Dig_1 < 10;Dig_1 ++)
for (int Dig_2 = 0 ;Dig_2 <10 ;Dig_2 ++)
for (int Dig_3 = 1 ;Dig_3 <10 ;Dig_3 ++)
if (Math.pow((double) Dig_1,3)+ Math.pow((double) Dig_2,3) + Math.pow((double) Dig_3,3) == Dig_1 + Dig_2 * 10 + Dig_3 * 100 )
System.out.print(Dig_3 + “” + Dig_2 + “” + Dig_1 + " ");
}
}
1
2
3
4
5
6
7
8
9
10
11
运行结果：
注：素数即是除了1和它本身以外不再有其他因数的自然数。程序中可以用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
public class JavaBasic05 {
public static void main(String[] args) {
//另解：按照题目的提示：用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
//下面采用的解题思路：如果一个数能被小于等于此数平方根的素数整除，则此数不是素数，否则是素数
//1不是素数，2是素数
Scanner input = new Scanner(System.in);
System.out.print(“请输入判断区间的下界(不包括此数)：”);
int min = input.nextInt();
System.out.print(“请输入判断区间的上界(不包括此数)：”);
int max = input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
运行结果：
要求，根据键盘录入的行数，决定等腰三角形的行数。
public class JavaBasic06 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入想要打印的等腰三角形的行数：”);
int num = input.nextInt();
for (int i = 1;i<= num ;i ++){ //i用于控制行数
for (int blank = 1;blank <= num-i;blank ++) //打印空白
System.out.print(" “);
for (int star = 1;star <= i * 2 - 1 ;star ++) //打印五角星
System.out.print(”*");
System.out.println(); //换行
}
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果：
public class JavaBasic07 {
public static void print(int num) {
for (int i = 1;i <= num;i ++) {
for (int j = 1; j <= i; j++)
System.out.print(i + “*” + j + “=” + i * j + " ");
System.out.println();
}
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个整数：”);
int num = input.nextInt();
print(num);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：
请编程求出1000 以内的所有完数。
public class JavaBasic08 {
public static void main(String[] args) {
int sum = 0;
for (int i = 2;i < 1000;i +=2) { //最小的完数是2，并且完数都是偶数
for (int j = 1; j < i; j++)
if (i % j == 0)
sum += j;
if (i == sum)
System.out.print(i + " ");
sum = 0;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果：
注：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的就可以了。
public class JavaBasic09 {
public static void main(String[] args) {
/*错误
outer:
for (int Dig_1 = 1;Dig_1 <= 4;Dig_1 ++)
for (int Dig_2 = 1;Dig_2 <= 4;Dig_2 ++)
for (int Dig_3 = 1;Dig_3 <= 4;Dig_3 ++)
if (Dig_1 == Dig_2 || Dig_2 == Dig_3 || Dig_3 == Dig_1)
continue outer;
else
System.out.print(Dig_3 + “” + Dig_2 + “” +Dig_1 + " ");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
运行结果：
/*
//采用ArrayList集合来求
int digitNum = 0; //输入的正整数的位数
*/
//使用数组来求
String s= Integer.toString(num); //将输入的正整数转换成字符串
char arr[] = s.toCharArray(); //将字符串存入字符数组
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
运行结果：
注：提前告诉你答案是32.164
public class JavaBasic11 {
public static void main(String[] args) {
int numerator = 2 , denominator = 1; //第一个数字是2/1
double result = 0;
System.out.print(numerator + “/” + denominator);
for (int num = 1;num <= 20; num ++) { //计算前20项和–循环20次
result += (double) numerator / denominator;
numerator += denominator;
denominator = numerator - denominator;
System.out.print(" + " + numerator + “/” + denominator); //分子：numerator，分母：denominator
}
System.out.println(“ 结果是:” + result);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
运行结果：
public class JavaBasic12 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“求前 n 个数的和，输入 n 的值（n > 0）:”);
int n = input.nextInt();
int sum = 0;
for (;n > 0;n --)
sum += n;
System.out.print("和为 " + sum);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
运行结果：
public class JavaBasic13 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“求前 n 个数积，输入 n 的值（n > 0）:”);
int n = input.nextInt();
int accumulate = 1;
for (;n > 0;n --)
accumulate *= n;
System.out.print("积为 " + accumulate);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
运行结果：
public class JavaBasic14 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请分别输入这三个数：”);
int num1 = input.nextInt(),num2 = input.nextInt(),num3 = input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
运行结果：
注：使用Math.sqrt(double a) 方法可以求a的平方根。
// //错误示例：
// //逆向思维，先求出10000(10000 = 100 * 100)内大于100（100 = 10 * 10）的完全平方数，再减去100和268
// int count = 0;
// //结果仍然是错误的，漏掉9933，9933 + 268 = 10201 ,是101的平方
// for (int i = 11; i * i - 100 < 10000; i++) {
// System.out.print(i * i - 100 + " “); //如果for循环中判断条件是 i <100,则求得的最大数是9701
// count++;
// //在这里还要去掉 加上100和加上268都是完全平方数的数。相当于求：一个整数，它加上100 和 加上268后都是一个完全平方数，问题和题目要求类似。故此方法复杂。
// if (i * i - 268 > 0 ) {
// System.out.print(i * i - 268 + " “);
// count++;
// if (count % 10 == 0)
// System.out.println();
// }
// }
// System.out.print(” 在1万以内，这样的数有” + count + “个”);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
运行结果：
public class JavaBasic16 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“求n以内所有的奇数和偶数和，输入n:”);
int num = input.nextInt();
int oddSum = 0,evenSum = 0;
for (int i = 1;i <= num;i += 2)
oddSum += i;
//num为偶数，则evenSum - oddSum = (num - 3)/ 2 + 2;
//num为奇数，则oddSum - evenSum = (num - 3)/ 2 + 2;
evenSum = num % 2 == 0 ? (num - 3)/ 2 + 2 + oddSum : oddSum - (num - 3)/ 2 - 2;
System.out.print(num + “以内所有的奇数和为：” + oddSum + “，所有的偶数和为” + evenSum);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果：
public class JavaBasic17 {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
运行结果：
public class JavaBasic18 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“输入一个数：”);
int num = input.nextInt();
int count = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
运行结果：
public class JavaBasic19 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个整数：”);
int num = input.nextInt();
if(num % 2 == 0)
System.out.print(“您输入的数字是偶数”);
else
System.out.print(“您输入的数字是奇数”);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
运行结果:
public class JavaBasic20 {
public static boolean isPrime(int num) {
//采用最简单直白的方式 判断一个数是否是 素数
for (int i = 2;i <= Math.sqrt(num);i ++)
if (num % i == 0)
return false; //不是素数
return true;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
运行结果：
public class JavaBasic21 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请分别输入这三个数：”);
int max = input.nextInt(), mid = input.nextInt(), min = input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
运行结果：
反射部分和错误示例 参考 CSDN 文章 java实现值交换（swap）
内容较复杂，写进了CSDN 文章 Java–交换两数的值 中，截图如下：
public class JavaBasic23 {
//用于判断这一个数是否是自守数
public static boolean isSelfGuardingNumber (int num) {
//boolean flag = true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果：
public class JavaBasic24 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“您现在有多少钱（元）？”);
int money =input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
运行结果：
public class JavaBasic25 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入井深（m）：”);
Double wellDepth = input.nextDouble();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
运行结果:
public class JavaBasic26 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个正整数:”);
int num = input.nextInt();
int sum = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：
public class JavaBasic27 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入判断区间的上界(不包括此数)：”);
int max = input.nextInt();
int sum = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
运行结果：
当输入n为奇数时，求1/1 + 1/3 + 1/5 +… + 1/n 的结果。
public class JavaBasic28 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入n的值：”);
int n = input.nextInt();
double result = 0;
double denominator = n % 2 ==0 ? 2 :1; //如果n是偶数，第一个相加的分数的分母为2，如果n是奇数，则第一个相加的分母为1
for (double i = denominator;i <= n; i = i +2)
result += 1 / i;
System.out.print(“函数运算的结果是：” + String.format(“%.2f”, result)); //保留两位小数
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果:
public class JavaBasic29 {
public static void main(String[] args) {
//闰年是指能被4整除，但是不能被100整除的年份 或者 能被400整除的年份
//平年2月有28天，闰年2月有29天
Scanner input = new Scanner(System.in);
System.out.print(“请输入年份和月份:”);
int year = input.nextInt();
int month = input.nextInt();
int day = 28;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
break;
case 2:
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
day = 29;
break;
case 4:
case 6:
case 9:
case 11:
break;
}
System.out.print(“在 " + year + " 年 " + month + " 月一共有 " + day + " 天。”);
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
运行结果：
public class JavaBasic30 {
public static void main(String[] args) {
int moneyPreferential = 16 + 8 + 3;
double moneyDiscount = 24 + 8 + 3 > 30 ? (24 + 8 + 3) * 0.8 : 24 + 8 + 3;
double result = moneyPreferential < moneyDiscount ? moneyPreferential : moneyDiscount;
System.out.print(“这个小伙要点这三样东西，最小要花 " + result + " 元”);
}
}
1
2
3
4
5
6
7
8
运行结果：
public class JavaExtend01 {
//兔子 对数为1，1，2，3，5，8，13，21
public static int rabbit(int month) {
if (month == 1 || month == 2)
return 1; //第一个月和第二个月 兔子的对数均为1 ，没有出生的新兔子
return rabbit(month - 1) + rabbit(month - 2);
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“需要打印至几月份?”);
int num = input.nextInt();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：
public class JavaExtend02 {
/*
参考：斐波那契数列
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
运行结果：
public class JavaExtend03 {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
运行结果：
public class JavaExtend04 {
//JavaBasic03中的getRandomArr(int num)方法进行部分修改
public static int[] getRandomArr(int num , int digit) {
int[] arr = new int[num + 1]; //将数组的元素设置成num + 1，因为后面还要插入一个元素，设置成num会出现java.lang.ArrayIndexOutOfBoundsException：数组越界错误
int i = 0;
for (;i < num;i ++)
arr[i] = new Random().nextInt(arr.length); //数组中前面的 num 个数随机生成，后面一个数用户输入或者随机生成，数组中一共 num +1 个数。
arr[i] = digit;
return arr;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
运行结果：
public class JavaExtend05 {
//交换函数，与JavaBasic22中四、利用数组完全一样。
//定义为静态方法
//如果不定义为静态方法，则在主函数中需要依赖于对象，需要通过对象来调用
public static void swap(int[] arr,int num1,int num2){
int temp = arr[num1];
arr[num1] = arr[num2];
arr[num2] = temp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
运行结果:
版权声明：
本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。
本文网址：https://www.bianchenghao6.com/h6javajc/18638.html