本文参考 嗨客网 Java 实战

前言

本篇文章给大家安利一些关于 Java 基础的练习题，每道题都附有答案链接，答案解题的每个步骤到运行结果都十分详细，十分适合小白拿来练习，也十分适合准备面试的各位复习下 Java 基础，这篇文章我会不断更新，题目都是对应 Java 基础中的各个知识点，大家在学习了Java 基础之后，做几道相关的练习题，复习一下该知识点，在学习过程中，觉得十分抽象、晦涩难懂的知识点，配合一道案例题，或许会有意想不到的效果哦！
 

目录

Java入门

• Java HelloWorld
• Java注释

Java变量

• 01 Java变量定义
• 02 Java数据类型
• 03 Java变量运算
• 04 Java变量运算
• 05 Java常量

Java三元运算符

• 01 Java三元运算符
• 02 Java三元运算符
• 03 Java三元运算符

Java条件判断

• 01 Java if条件判断
• 02 Java if条件判断
• 03 Java switch
• 04 Java switch
• 05 Java switch

Java循环

• 01 Java for循环
• 02 Java for循环
• 03 Java for循环
• 04 Java for循环
• 05 Java for循环嵌套
• 06 Java for循环嵌套
• 07 Java break
• 08 Java continue
• 09 Java while循环
• 10 Java do while循环
• 11 Java死循环

Java随机数

• 01 Java随机数
• 02 Java随机数
• 03 Java随机数

Java数组

• 01 Java定义数组
• 02 Java遍历数组
• 03 Java数组
• 04 Java数组

Java方法

• 01 Java方法
• 02 Java方法
• 03 Java逢七过游戏

2020.08.20更，未完待续。。。。。

正文：Java基础练习题

Java入门

题目一

题目：使用 Java 实现，编写第一个程序，即 Java HelloWorld。

答案：https://haicoder.net/case/java/java-helloworld.html

题目二

题目：使用 Java 的注释，包括单行注释和多行注释。

答案：https://haicoder.net/case/java/java-descripotion.html

Java变量

题目一

题目：Java变量定义，分别定义 Java 的 8 种 基本数据类型 的变量。

答案：https://haicoder.net/case/java/java-variable.html

题目二

题目：Java数据类型，选用 Java 合适的数据类型定义变量。

答案：https://haicoder.net/case/java/java-datatype.html

题目三

题目：Java变量运算，运用 Java 变量计算圆柱体积。

答案：https://haicoder.net/case/java/java-variable-operator.html

题目四

题目：Java变量运算，运用 Java 变量根据父母身高预测出子女身高。

答案：https://haicoder.net/case/java/java-variable-operator2.html

题目五

题目：Java 常量，完成 Java 常量的基本使用。

答案：https://haicoder.net/case/java/java-contants.html

Java三元运算符

题目一

题目：Java三元运算符，运用 Java 三元运算符进行运算。

答案：https://haicoder.net/case/java/java-ternary-operator.html

题目二

题目：Java三元运算符，某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点 24 元，油炸花生米单点 8 元，米饭单点 3 元。订单满 30 元 8 折优惠。鱼香肉丝优惠价 16 元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？

答案：https://haicoder.net/case/java/java-ternary-operator2.html

题目三

题目：Java三元运算符，运用 Java 三元运算符获取几个数中的最大值。键盘录入三位同学的年龄，用程序实现获取这三个同学的最大年龄。

答案：https://haicoder.net/case/java/java-ternary-operator3.html

Java条件判断

题目一

题目：Java if条件判断，李雷想买一个价值 7988 元的新手机,他的旧手机在二手市场能卖 1500 元,而手机专卖店推出以旧换新的优惠,把他的旧手机交给店家,新手机就能够打 8 折优惠。

答案：https://haicoder.net/case/java/java-if.html

题目二

题目：Java if条件判断，根据用户输入的年龄，判断用户属于哪个年龄段。

答案：https://haicoder.net/case/java/java-if2.html

题目三

题目：Java switch，键盘录入一个 0 到 7 数字，使用 switch 输出这个数字对应的星期。

答案：https://haicoder.net/case/java/java-switch.html

题目四

题目：Java switch，键盘录入一个月份数字，使用 switch 输出这个月份对应的季节。

答案：https://haicoder.net/case/java/java-switch2.html

题目五

题目：Java switch，用户输入星期数，使用 Java switch 匹配显示对应的运动项目。输入星期数，显示今天的运动项目，周一跑步、周二游泳、 周三慢走、 周四单车、 周五爬山、周六拳击、周日休息。

答案：https://haicoder.net/case/java/java-switch3.html

Java流程控制

题目一

题目：Java for循环，在中国历法中有十二生肖年份，2019 年是己亥猪年,请在控制台输出从 1949 年(包含)到 2019 年(包含)中所有是猪年的年份。

答案：https://haicoder.net/case/java/java-for.html

题目二

题目：Java for循环，中国使用的公历有闰年的说法，闰年的规则是:四年一闰,百年不闰,四百年再闰。(年份能够被 4 整除但不能被 100 整除算是闰年,年份能被 400 整除也是闰年)。请打印出 2000 年到 2019 年的所有闰年年份。

答案：https://haicoder.net/case/java/java-for2.html

题目三

题目：Java for循环，计算出 1~100 之间的偶数和，并把求和结果在控制台输出 。

答案：https://haicoder.net/case/java/java-for3.html

题目四

题目：Java for循环，请输出所有 “水仙花数” 。“水仙花数” 指的是一个三位数，个位、十位、百位的数字立方和等于原数本身。

例如：153 333 + 555 + 111 = 153。

答案：https://haicoder.net/case/java/java-for4.html

题目五

题目：Java for循环嵌套，使用 for 循环语句,在控制台打印出一个四行五列的长方形,效果如下:

@@@@@
@@@@@
@@@@@
@@@@@

答案：https://haicoder.net/case/java/java-for-nest.html

题目六

题目：Java for循环嵌套，使用 for 循环语句，在控制台打印出一个五行的三角形，效果如下:

@
@@
@@@
@@@@
@@@@@

答案：https://haicoder.net/case/java/java-for-nest02.html

题目七

题目：Java break，运用 break 结束当前循环 ，计算 1、2、3、4、5 这一组数据，但要求只计算前 3 个数的和。

答案：https://haicoder.net/case/java/java-break.html

题目八

题目：Java continue，运用 continue 跳过当前循环 ，计算 1、2、3、4、5 这一组数据，但要求只计算 1、2、3、5 的和。

答案：https://haicoder.net/case/java/java-continue.html

题目九

题目：Java while循环，运用 Java while 循环 计算出 1 到 10 的和。

答案：https://haicoder.net/case/java/java-while.html

题目十

题目：Java do while循环，运用 Java do while循环 计算出 1 到 10 的和。

答案：https://haicoder.net/case/java/java-do-while.html

题目十一

题目：Java 死循环，利用死循环，持续获取用户输入。（应用场景如：持续输入每一个学生成绩）

答案：https://haicoder.net/case/java/java-dead-cycle.html

Java随机数

题目一

题目：Java随机数，运用 Java 的 Random 得到随机数，获取 0 到 9 内的随机数（包括 0 和 9）。

答案：https://haicoder.net/case/java/java-random.html

题目一

题目：Java随机数，运用 Java 的 Random 函数得到区间随机数。

1. 生成一个 1-10 之间的随机数。
2. 生成一个 3-15 之间的随机数。
3. 生成一个 5-999 之间的随机数。

答案：https://haicoder.net/case/java/java-random2.html

题目二

题目：Java随机数，运用 Java 的 Random 函数实现猜数字游戏。

随机产生一个 1-100 之间的数字，然后让玩家不断猜测，如果猜大，提示过大，如果猜小，提示过小，如果猜中则程序停止。

答案：https://haicoder.net/case/java/java-random3.html

Java数组

题目一

题目：Java定义数组，Java 数组 的定义格式分别为：静态初始化、动态初始化，使用静态初始化和动态初始化定义数组。

答案：https://haicoder.net/case/java/java-array-init.html

题目二

题目：Java遍历数组，请使用静态初始化的方式，创建一个长度为 5 的整数数组，并为数组中的元素赋值，遍历数组,在同一行打印所有元素，元素之间用空格隔开，比如：如果数组为 { 1,2,3,4,5 } 则打印结果为：1 2 3 4 5。

答案：https://haicoder.net/case/java/java-arrary-walk.html

题目三

题目：Java 数组 ，创建一个长度为 6 的整数数组，随机生成六个 0 (包含) - 100 (不包含) 之间的整数存放到数组中，然后计算出数组中所有元素的和并打印。

答案：https://haicoder.net/case/java/java-array.html

题目四

题目：Java数组，运用 Java 数组 存储学生成绩，遍历数组 得出成绩最高的学生。

答案：https://haicoder.net/case/java/java-array2.html

Java方法

题目一

题目：Java 方法 ，定义一个方法，该方法能够找出三个 整数 中的最大值并返回。

答案：https://haicoder.net/case/java/java-method.html

题目二

题目：Java 方法 ，数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。请定义一个方法，方法能够得到小数 类型 数字的绝对值并返回。

答案：https://haicoder.net/case/java/java-method2.html

题目三

题目：Java 方法 ，使用 Java 实现逢七过这个游戏，游戏规则如下：从 1 到 20 开始报数，当玩家要报的数字包含 7 或者是 7 的倍数时都要说：过。

答案：https://haicoder.net/case/java/java-method3.html

彩蛋

Java 基础练习题内容，剩下的题目我会继续更新，先提前小小的剧透一下后面的内容哦！

你以为到这里就结束了吗？还有Java基础增强的习题，奉上大纲：

但是因为文章数量过多，整理不易，所以如果更新过慢，请大家谅解，文章我会尽自己最大速度更新，大家可以先关注我，或者收藏下这篇文章，我会持续更新的，以上案例是提供给有一定 Java 基础的同学看的，如果感觉做题有些压力，可以先到各类教程网学习Java，本人这里当然首推上方习题及答案来源的 嗨客网。

更多

更多精选文章，可以关注下方公众号：

参考：

1. 变量的练习：

   • 声明一个变量，一次声明多个变量。

   • 声明变量直接初始化，先声明变量，而后再给变量初始化。

   • 声明整型变量g，声明另一个整型变量h并赋值为h+10，输出变量h的值。

   • 声明整型变量i，在i本身基础之上增10，输出变量i的值。

   • 声明一些正确的和错误的变量名。

   参考案例：

   //变量的演示
   public class VarDemo {
       public static void main(String[] args) {
           //1)变量的声明:----相当于在银行开帐户
           int a; //声明一个整型的变量，名为a
           int b,c,d; //声明三个整型的变量，名为b,c,d
           //int a; //编译错误，变量不能同名
   
           //2)变量的初始化:----相当于给帐户存钱
           int e = 250; //声明整型变量e并赋值为250
           int f;   //声明整型变量f
           f = 250; //给f赋值为250
   
           //3)变量的使用:----使用的是帐户里面的钱
           int g = 5;
           int h = g+10; //取出g的值5，加10后，再赋值给变量h
           System.out.println(h); //输出变量h的值15
           System.out.println("h"); //输出h，双引号中的原样输出
           g = g+10; //在g本身基础之上增10
           System.out.println(g); //输出g的值15
   
           //int i = 3.14; //编译错误，数据类型必须匹配
           //System.out.println(j); //编译错误，变量j未声明
           int j;
           //System.out.println(j); //编译错误，变量j未初始化
   
           //4)变量的命名:
           int a1,a_5$,_3c,$_b;
           //int a*b; //编译错误，不能包含*号等特殊符号
           //int 1a; //编译错误，不能以数字开头
           int aa = 5;
           //System.out.println(aA); //编译错误，严格区分大小写
           //int class; //编译错误，不能使用关键字
   
           //int k; //不直观，不建议
           //int 年龄; //允许，但不建议
           //int nianLing; //既不直观也不专业，必须杜绝
           int age; //建议"英文的见名知意"
           int score,myScore,myJavaScore; //建议"小驼峰命名法"
   
       }
   }
   

2. 基本数据类型的练习：int

   • 声明初始化两个以上整数变量，并且输出两个整数变量的除法结果
   • 声明两个很大的变量，然后相加，输出运算结果，测试运算溢出现象

   参考案例：

   //1)int:整型，4个字节，-21个多亿到21个多亿
   int a = 25; //25为整数直接量，默认为int类型
   //int b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
   System.out.println(5/2);   //2
   System.out.println(2/5);   //0
   System.out.println(5/2.0); //2.5
   int c = 2147483647; //int的最大值
   c = c+1;
   System.out.println(c); //-2147483648(int的最小值)，发生溢出了，需要避免
   

3. 基本数据类型的练习：long

   • 声明初始化两个以上的长整型变量
   • 声明变量存储几个较大数据的运算，演示：若有可能溢出建议将L设计在第1个数字后。

   参考案例：

   //2)long:长整型，8个字节，很大很大很大
   long a = 25L; //25L为长整型直接量，默认为long型
   //long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
   long c = 10000000000L; //100亿L为长整型直接量
   
   long d = 1000000000*2*10L;
   System.out.println(d); //200亿
   long e = 1000000000*3*10L;
   System.out.println(e); //不是300亿
   long f = 1000000000L*3*10;  //运算若有可能溢出，建议在第1个数字后加L
   System.out.println(f); //300亿
   

4. 基本数据类型的练习：double

   • 声明初始化两个以上的浮点型变量
   • 声明几个浮点型变量并将它们做数学操作，演示double运算的舍入误差问题

   参考案例：

   //3)double:浮点型，8个字节，很大很大很大
   double a = 3.14159; //3.14159为浮点数直接量，默认为double类型
   float b = 3.14159F; //3.14159F为float型-----了解即可
   
   double c=6.0,d=1.9;
   System.out.println(c-d); //0.10000000000000009，有可能发生舍入误差
   

5. 基本数据类型的练习：boolean

   • 声明初始化两个以上的布尔型变量

   参考案例：

   //4)boolean:布尔型，1个字节
   boolean a = true;  //true为布尔型直接量
   boolean b = false; //false为布尔型直接量
   //boolean c = 25; //编译错误，布尔型只能赋值为true或false
   

6. 基本数据类型的练习：char

   • 声明初始化五个以上的字符型变量
   • 声明字符型变量，演示转义符

参考案例：

   //5)char:字符型，2个字节
   char c1 = '女'; //字符女
   char c2 = 'f';  //字符f
   char c3 = '6';  //字符6
   char c4 = '*';  //字符*
   //char c5 = 女; //编译错误，字符型直接量必须放在单引号中
   //char c6 = ''; //编译错误，必须有字符
   //char c7 = '女性'; //编译错误，只能有一个字符
   
   char c8 = '\\';
   System.out.println(c8);

7. 基本数据类型的转换：两种方式

   • 声明几个变量，演示自动类型转换和强制类型转换的语法
   • 声明一个较大类型的长整型变量，演示强转可能会发生的溢出问题
   • 声明一个较大精度的浮点型变量，演示强转可能会发生的丢失精度问题

   参考案例：

   int a = 5;
   long b = a;     //自动类型转换
   int c = (int)b; //强制类型转换
   
   long d = 5; //自动类型转换
   double e = 5; //自动类型转换
   
   long f = 10000000000L;
   int g = (int)f;
   System.out.println(g); //1410065408，强转有可能发生溢出
   double h = 25.987;
   int i = (int)h;
   System.out.println(i); //25，强转有可能丢失精度
   

8. 基本数据类型的转换：两点规则

   • 声明两个byte型变量b1和b2，并赋值为直接量
   • 声明一个byte型变量，并赋值为b1与b2的和

   参考案例：

   byte b1 = 5;
   byte b2 = 6;
   byte b3 = (byte)(b1+b2);
   
   System.out.println(2+2);     //4
   System.out.println(2+'2');   //52，2加上'2'的码50
   System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
   

9. 运算符的练习：算术

   • 输出几个整数取模，验证结果
   • 声明两个整型变量，演示单独使用时的自增和自减
   • 声明几个整型变量，演示被使用时的自增和自减

   参考代码：

   System.out.println(5%2); //1，商2余1
   System.out.println(8%2); //0，商4余0----整除
   System.out.println(2%8); //2，商0余2
   
   //单独用----自增
   int a=5,b=5;
   a++; //相当于a=a+1
   ++b; //相当于b=b+1
   System.out.println(a); //6
   System.out.println(b); //6
   
   //单独用----自减
   int a=5,b=5;
   a--; //相当于a=a-1
   --b; //相当于b=b-1
   System.out.println(a); //4
   System.out.println(b); //4
   
   //被使用----自增
   int a=5,b=5;
   int c = a++; //1)将a++的值5赋值给c  2)a自增1变为6
   int d = ++b; //1)将++b的值6赋值给d  2)b自增1变为6
   System.out.println(a); //6
   System.out.println(b); //6
   System.out.println(c); //5
   System.out.println(d); //6
   
   //被使用----自减
   int a=5,b=5;
   int c = a--; //1)将a--的值5赋值给c  2)a自减1变为4
   int d = --b; //1)将--b的值4赋值为d  2)b自减1变为4
   System.out.println(a); //4
   System.out.println(b); //4
   System.out.println(c); //5
   System.out.println(d); //4
   

10. 运算符的练习：关系

• 声明几个变量，演示最基本的>，<，>=，<=，==，!=操作
• 演示关系运算符和算术运算符联合使用的效果

参考代码：

int a=5,b=10,c=5;
boolean b1 = b>a;
System.out.println(b1);   //true
System.out.println(c<b);  //true
System.out.println(a>=c); //true
System.out.println(b<=a); //false
System.out.println(b==c); //false
System.out.println(a!=c); //false

System.out.println(a+c>10); //false
System.out.println(b%2==0); //true
System.out.println(c++>5);  //false------c自增1变为6
System.out.println(c++>5);  //true-------c自增1变为7

11. 运算符的练习：逻辑

• 声明三个整型变量，演示&&和||，演示!
  • &&的演示要求：true+false、false+true、true+true、false+false
  • ||的演示要求：true+false、false+true、true+true、false+false
  • !的演示要求：true、false
• 演示短路&&与短路||

参考代码：

int a=5,b=10,c=5;
//演示&&
boolean b1 = b>=a && b<c;
System.out.println(b1);          //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
//演示||
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
//演示!
boolean b2 = !(a<b);
System.out.println(b2);     //!true=false
System.out.println(!(a>b)); //!false=true

//演示&&的短路
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

//演示||的短路
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c);  //5，发生短路了

12. 运算符的练习：赋值

• 声明一个整型变量，演示扩展赋值+=、-=、*=、/=、%=的效果
• 声明short型变量s，演示简单赋值运算的自增10，演示扩展赋值运算的自增10

参考代码：

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

short s = 5;
//s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)

13. 运算符的练习：字符串连接

• 声明整型变量age和字符串型变量name，输出字符串连接的结果
• 输出几个数据的拼接，演示字符串连接的同化作用

参考代码：

//演示字符串连接
int age = 38;
System.out.println("age="); //age=
System.out.println(age);    //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了

String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了

//演示同化作用
System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

14. 运算符的练习：条件/三目

• 声明并初始化整型变量，使用条件运算符实现：若>0则给flag赋值为1，否则赋值为0
• 声明两个整型变量，使用条件运算符实现：求这两个变量的最大值

参考代码：

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max);

15. 分支结构的练习：if

• 偶数的判断：声明并初始化一个整型变量，判断该数是否是偶数
• 满500打8折：声明并初始化一个浮点型价格，若满500则打8折

参考代码：

//1)偶数的判断:
int num = 6; //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折
//带数(600.0,300.0)
double price = 300.0; //消费金额
if(price>=500){ //满500
    price*=0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

16. 分支结构的练习：if…else

• 偶数、奇数的判断：声明并初始化一个整型变量，判断该数是偶数还是奇数
• 满500打8折：声明并初始化一个浮点型价格，若满500则打8折，否则打9折

参考代码：

//if..else结构的演示
public class IfElseDemo {
    public static void main(String[] args) {
        //1)偶数、奇数的判断:
        int num = 5; //带数(6,5)
        if(num%2==0){
            System.out.println(num+"是偶数");
        }else{
            System.out.println(num+"是奇数");
        }
        System.out.println("继续执行...");

        //2)满500打8折，不满500打9折:
        double price = 300.0; //带数(600.0,300.0)
        if(price>=500){ //满500，打8折
            price*=0.8;
        }else{ //不满500，打9折
            price*=0.9;
        }
        System.out.println("最终结算金额为:"+price);
    }
}

17. 声明两个整型变量a和b并分别赋值，找到a和b中的最大值，并输出。用两种方式实现：条件运算符、if…else分支结构

参考代码：

package test;
public class Day03 {
    public static void main(String[] args) {
		/*
        int a=8,b=5;
        int max = a>b?a:b;
        System.out.println("max="+max);
        */
        
        int a=8,b=5;
        int max;
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println("max="+max);
    }
}

18. 声明一个整型变量year并存储年份，判断其是平年还是闰年，若是闰年则输出"某某某年是闰年"，否则输出"某某某年是平年"。

参考代码：

package test;
public class Day03 {
    public static void main(String[] args) {
		/*
          闰年的判断公式:
          1)4年一闰，百年不闰，就是：能被4整除，并且，不能被100整除
            或者
          2)400年再闰，就是：能被400整除
         */
        int year = 2000; //年份  //带数(2021,2020,2000)
        if((year%4==0 && year%100!=0) || year%400==0){
            System.out.println(year+"是闰年");
        }else{
            System.out.println(year+"是平年");
        }
    }
}

19. ScoreLevel成绩等级判断：接收用户输入的成绩，判断成绩的等级ABCD

参考代码：

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();

        //带数(888,-45,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }

    }
}

20. CommandBySwitch命令解析程序：接收用户输入的命令，依据命令做不同的操作

参考代码：

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("取款操作...");
                break;
            case 2:
                System.out.println("存款操作...");
                break;
            case 3:
                System.out.println("查询余额操作...");
                break;
            case 0:
                System.out.println("退出成功");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

21. Guessing猜数字之while版：随机生成一个数，由用户来猜，猜不对则反复猜，并给出大小提示，猜对的则结束，用while来实现。

参考代码：

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内
        System.out.println(num); //作弊
        
        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");
    }
}

22. Guessing猜数字之do…while版：随机生成一个数，由用户来猜，猜不对则反复猜，并给出大小提示，猜对的则结束，用do…while来实现。

参考代码:

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt(); //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}

23. 接收用户输入的一个整数num，判断它的正负零值，正数则输出"+“，负数则输出”-“，0则输出"0”

参考代码：

package test;
import java.util.Scanner;
public class Day04 {
    public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个整数:");
        int num = scan.nextInt();

        if(num>0){
            System.out.println("+");
        }else if(num<0){
            System.out.println("-");
        }else{
            System.out.println("0");
        }
    }
}

24. 接收用户输入的年份year和月份month，计算该年该月的天数，并输出

参考代码：

package test;
import java.util.Scanner;
public class Day04 {
    public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
        System.out.println("请输入年份:");
        int year = scan.nextInt();
        System.out.println("请输入月份:");
        int month = scan.nextInt();
        int days = 0; //天数
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                days = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                days = 30;
                break;
            case 2:
                if((year%4==0 && year%100!=0) || year%400==0){
                    days = 29;
                }else{
                    days = 28;
                }
        }
        System.out.println(year+"年的"+month+"月共"+days+"天");
    }
}

25. 利用循环语句while计算数字1到100的和，并输出

参考代码：

package test;
public class Day04 {
    public static void main(String[] args) {
		int sum = 0; //和
        int i = 1;
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println("sum="+sum);
    }
}

26. Addition随机加法运算器：由系统随机出10道加法题，而后由用户来答题，答题后输出"答对了"或"答错了"，答对1题得10分，答错1题不扣分,最后输出总分数。

参考代码：

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //得分
        for(int i=1;i<=10;i++){ //10次    (1)25+36=?
            int a = (int)(Math.random()*100); //加数a(0到99的随机数)
            int b = (int)(Math.random()*100); //加数b(0到99的随机数)
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
            System.out.println("算吧!");
            int answer = scan.nextInt(); //2)答题
            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score+=10; //答对1题加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

27. MultiType九九乘法表：输出九九乘法表

参考代码：

package day05;
//九九乘法表
public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ //控制行
            for(int i=1;i<=num;i++){ //控制列
                System.out.print(i+"*"+num+"="+i*num+"\t");
            }
            System.out.println(); //换行
        }
    }
}

28. 数组小代码练习：声明

• 定义至少两个数组，设计包含一些元素

参考代码：

//声明整型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];

29. 数组小代码练习：初始化

• 定义至少三个数组，演示三种元素初始化方式

参考代码：

//2)数组的初始化:--初始化的是数组中的数据
int[] arr1 = new int[3]; //0,0,0
int[] arr2 = {2,5,8}; //2,5,8
int[] arr3 = new int[]{2,5,8}; //2,5,8
int[] arr4;
//arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
arr4 = new int[]{2,5,8}; //正确

30. 数组小代码练习：访问

• 定义数组，输出数组的长度
• 定义数组并分别给每个元素赋值，输出最后一个元素的值
• 编写代码演示数组操作常见的异常----数组下标越界

参考代码：

//3)数组的访问:--访问的是数组中的数据
int[] arr = new int[3];
System.out.println(arr.length); //3，输出arr的长度
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
//arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

31. 数组小代码练习：遍历

• 定义数组，包含10个元素，遍历数组，给每个元素赋值为0到99之间的随机数，输出每个元素的值

参考代码：

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
    System.out.println(arr[i]); //输出每个元素的值
}

32. 利用for循环计算：求数字1到100之内，所有偶数的和，并输出

参考代码：

package test;
public class Day05 {
    public static void main(String[] args) {
		int sum = 0;
        for(int i=2;i<=100;i+=2){
            sum+=i;
        }
        System.out.println("sum="+sum);
    }
}

33. 利用for循环计算：求8的阶乘，并输出

参考代码：

package test;
public class Day05 {
    public static void main(String[] args) {
		int num = 1; //阶乘
        for(int i=1;i<=8;i++){
            num*=i;
        }
        System.out.println("num="+num);
    }
}

34. 利用for循环计算：打印字符*组成的等腰三角形，输出结果如下所示：

     *
    ***
   *****
  *******
 *********
***********

参考代码：

package test;
public class Day05 {
    public static void main(String[] args) {
		for(int i=1;i<=6;i++){
            for(int j=1;j<=6-i;j++){ //空格
                System.out.print(" ");
            }
            for(int k=1;k<=2*i-1;k++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

35. MaxOfArray求数组元素最大值并放在最后一个元素的下一个位置：声明整型数组并填充随机数据，找到最大值，将数组扩容并将最大值放末尾

参考代码：

package day06;
import java.util.Arrays;
//求数组元素的最大值，并将其放在最后一个元素的下一个位置
public class MaxOfArray {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }

        int max = arr[0]; //假设第1个元素为最大值
        for(int i=1;i<arr.length;i++){ //遍历剩余元素
            if(arr[i]>max){   //若剩余元素大于max
                max = arr[i]; //则将max修改为较大的
            }
        }
        System.out.println("最大值为:"+max);

        arr = Arrays.copyOf(arr,arr.length+1); //扩容
        arr[arr.length-1] = max; //将最大值max放到最后一个元素上
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

36. 数组排序的练习：声明整型数组并填充数据，排序，输出排序后数据，倒序输出数据

参考代码：

package day06;
import java.util.Arrays;
//数组的演示
public class ArrayDemo {
    public static void main(String[] args) {
        //8)数组的排序:
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }

        Arrays.sort(arr); //对arr进行升序排列

        System.out.println("数组排序后的数据:");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
        System.out.println("倒序输出:");
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }
}

37. 方法的练习：参数

• 定义say()无参无返回值方法，调用测试
• 定义sayHi()有一个参无返回值方法，调用测试
• 定义sayHello()有两个参无返回值的方法，调用测试

参考代码：

package day06;
//方法的演示
public class MethodDemo {
    public static void main(String[] args) {
        say();
        sayHi("zhangsan"); //String name="zhangsan"
        sayHello("zhangsan",25); //String name="zhangsan",int age=25
    }
    
    //无参无返回值
    public static void say(){
        System.out.println("大家好，我叫WKJ，今年38岁了");
    }
    
    //有参无返回值
    public static void sayHi(String name){
        System.out.println("大家好，我叫"+name+"，今年38岁了");
    }
    
    //有参无返回值
    public static void sayHello(String name,int age){
        if(age>=35){ //在某种特定条件下，提前结束方法
            return; //结束方法的执行
        }
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
    }
}

38. 方法的练习：返回值

• 定义getNum()无参有返回值方法，演示return的用法，调用测试
• 定义plus()两个参有返回值方法，调用测试
• 定义testArray()用于生成整型数组填充随机数并返回数组，调用测试

参考代码：

package day06;
//方法的演示
public class MethodDemo {
    public static void main(String[] args) {
        double a = getNum(); //getNum()值就是return后那个数
		System.out.println(a); //8.88，模拟对返回值的后续操作

        int b = plus(5,6);
        System.out.println(b); //11，模拟对返回值的后续操作
        int m=5,n=6;
        int c = plus(m,n); //传递的是m和n里面的数
        System.out.println(c); //11，模拟对返回值的后续操作

        int[] d = testArray();
        System.out.println("长度为:"+d.length); //10，模拟对返回值的后续操作
        for(int i=0;i<d.length;i++){ //模拟对返回值的后续操作
            System.out.println(d[i]);
        }
    }
    
    //无参有返回值
    public static double getNum(){
        //return "abc"; //编译错误，返回值类型不匹配
        return 8.88; //1)结束方法的执行  2)返回结果给调用方
    }
    
    //有参有返回值
    public static int plus(int num1,int num2){
        int num = num1+num2;
        return num; //返回的是num里面的那个数
        //return num1+num2; //返回num1与num2的和
    }
    
    //无参有返回值
    public static int[] testArray(){
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
        }
        return arr;
    }
}

39. 定义一个方法generate()

• 根据第一个参数生成指定长度的int数组；
• 根据第二个范围参数随机生成0到指定范围的随机数，填充到数组元素中，并将该数组返回；
• 测试数组内容。

参考代码：

package test;
public class Day06 {
    public static void main(String[] args) {
		int[] arr = generate(5,20);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    //生成随机数组方法
    public static int[] generate(int len,int max){
        int[] arr = new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*(max+1));
        }
        return arr;
    }
}