JavaSE 01 作业讲解和答案
1. 单选题
台式机，安卓手机，iPhone手机，他们其实都是计算机，计算机干的事情就是严格的执行人的指令，但是目前的科技条件下，电脑仍然有一个很大的短板，这个短板是？
A 思考
B 计算
答案：A
计算机最擅长的是运行固定的程序，就目前而言，计算机还缺少思考的能力。包括目前的人工智能，也缺少类似于人的思考过程。
我们以下棋的人工智能为例，包括五子棋，国际象棋，围棋等。在以前，计算机会根据对手的每一步，计算自己所有步骤的胜率，根据结果找出最优的下法。其中最杰出的代表就是1997年深蓝战胜了人类的国际象棋冠军卡斯帕罗夫。在国际象棋中，步骤是有限的，深蓝就在这有限个走法中找到胜率最大的。这种把所有情况都考虑到的方式叫做穷举法，适用于不是很复杂的情况，这是以前的人工智能。但是这种方式是有弊端的，比如围棋，围棋中可走的步数就太多了，计算量太大，利用穷举法就不现实，所以在下围棋的时候就会更换算法，比如：在201年AlphaGo对战人类顶级围棋大师的时候，就没有采取穷举法，而是借鉴了人类的思维习惯：推演。也就是，走一步，看三步。首先会判断，在哪几个地方可以落子，然后再判断每一个地方的胜率，找出胜率最大的，这样就不需要把整个棋盘中可以落子的所有地方都考虑完毕，大大减少了计算的时间。但是这种方式也是程序员提前写好的程序，还不能算是自我思考。2.单选题
计算机不能思考，那他是如何工作的呢，下面的描述哪个是对的？
A 等待人工智能的进一步发展，计算机能自己思考
B 人类告诉计算机如何计算，规则是什么
答案：B
我们将来写的代码就是告诉计算机如何计算的，计算机会按照我们编写的代码去运行3.多选题
任何计算机能执行的东西都是程序，下面的内容哪些是程序？
A 操作系统
B 360浏览器
C 安卓app
D 电脑病毒
答案：ABCD
只要是我们人为编写的，都是程序。
计算机中的程序有系统软件还有应用软件。
关于计算机的其他知识我已录了视频，可以下载观看。
链接：https://pan.baidu.com/s/1et04S2zgVInVNwvmnTuIfw
提取码：m6ga4.流程考察题
大多数程序都是顺序结构，计算机一步一步的执行我们的指令，请大家为黑马机器人排列指令，完成机器人进屋的操作
A 把门拉开
B 开锁
C 进入房间
D 关上房门
本题的目的是为了让大家在学习之前，初步了解一下什么是逻辑性。
所谓逻辑性，说白了就是事情进行的步骤，我们以后在写代码的时候也要能梳理逻辑。
答案能否自己梳理呢？5.流程考察题
请给下面的步骤排序，制作麦辣鸡腿堡
A 把第一片面包和第二片面包夹在一起
B 在第一片面包上面放麦辣鸡酱
C 拿两片面包
D 在第二片面包上放麦辣鸡
本题的目的是为了让大家在学习之前，初步了解一下什么是逻辑性。
所谓逻辑性，说白了就是事情进行的步骤，我们以后在写代码的时候也要能梳理逻辑。
答案能否自己梳理呢？6.操作题
安装JDK
Java 00 开发环境配置
7.操作题
配置环境变量
请参见视频和day01的笔记8.操作题
安装Notepad++
请参见视频和day01的笔记9.操作题
利用记事本和Notepad++分别写一个HelloWorld并成功运行
请参见视频和day01的笔记JavaSE 02 作业讲解和答案
题目1：（选择）
下列关于java变量声明那个是错误的：
A . int x = 5;
B. double d = 3.14;
C. char grade = ‘C’;
D. String name = ‘黑马程序员’;
讲解：D
字符串需要用双引号引起来
题目2：（看代码说结果）
看代码说结果，不要去运行。
double money = 10.0;
money = money + 5;
money -= 2.5;
money = money + 10;
money = money -3;
System.out.println(money)**程序从上往下依次执行，不断的修改 money **这个变量中的值
最终变化为：19.5
题目3：（代码题）
请用代码描述下列银行流水变化过程：
- 小明账户bankBalance初始值有500.00元
- 存入250元
- 支出100元
- 打印剩余存款
讲解：
double bankBalance = 500.0;
bankBalance = bankBalance + 250;
bankBalance = bankBalance - 250;
System.out.println(bankBalance);
题目4：（选择题）
变量名是一个单词或者是一组单词，用来描述一个数据的含义，方便人理解，变量名不能有空格。下面的名字哪些可以是变量名?
A. mybirthday
B. myname
C. my name
D. my birthday
E. 1987.
F. ”传智播客”
讲解：
AB正确，其他错误
C：不能有空格
D：不能有空格
E：不能以数字开头
F：变量名不能有双引号
题目5：（选择题）
关于变量的说法哪些是对的?
A. 一个变量一次就可以存储很多种不同的数据
B. 变量是值的容器,定义变量可以存放值
C. 变量可以随时修改存储数据的类型
D. 定义变量可以帮我们存储信息方便后面使用
讲解：
A：错误，一个变量只能存一个值
B：正确
C：错误，只有存储的值可以修改，数据类型一旦确定无法修改
D：正确
题目6：（选择题）
下面代码哪些是创建一个变量?
A. int myAge = 18;
B. myName='传智播客”;
C. myAge = 16;
D. String myName ;
讲解：
A：正确
B：错误，缺少数据类型，而且数据值也错误
C：错误，缺少数据类型
D：错误，没有赋值
题目7：（选择题）
int和float的区别是什么?
A. 区别是没有区别
B. int是变量, float是方法
C. int是用来存放整数数据的变量类型，float是存放小数的
D. int类型的数据要用”， 引号引起来
讲解：
A：错误，有区别
B：错误，int和float都是数据类型
C：正确
D：错误，整数不用双引号引起来
题目8：（代码题）
变量应该是先声哪后使用,请完成下面代码
A.声明字符串型变量name
B.声明字符串型变量birthday
C.声明整数类型变量age
D.声明float类型变量money
讲解：
A:String name = "尼古拉斯阿玮";
B:String birthday = "9月10日";
C:int age = 18;
D:float money = 999999999.99F;题目9（代码题）
请编写程序，分别定义8种基本数据类型的变量，并打印变量的值。
训练目标
java中的八种基本基本数据类型和变量的定义
训练提示
1、java中的8种基本数据类型都有什么？
2、定义变量的格式是什么？
3、变量名该怎样定义？
4、该怎样使用变量？
参考方案
定义变量，并输出变量的值。
训练步骤
1、创建java文件，定义类Test03，编写主方法。
2、在java语言中，定义变量必须明确变量的数据类型。八种基本数据类型包括byte、short、int、long、float、double、char、boolean。
3、定义变量的格式是：
数据类型 变量名 = 初始化值; // 声明变量并赋值
// 或
数据类型 变量名; // 先声明
变量名 = 初始化值; // 再赋值4、可以包含英文字母、数字字符、英文下划线（_）和英文美元符（$），并且不能以数字开头。在开发中，java变量的命名又最好符合“小驼峰”式的惯例规范，并且最好做到见名知意。
5、在输出语句中，直接调用变量名即可。
6、编译并运行代码，查看输出结果。
参考答案
public class Test01 {
public static void main(String[] args) {
// 定义byte类型变量，值为整数，只要在byte范围即可，byte范围：-128 ~ 127
byte b = 100;
System.out.println(b);
// 定义short类型变量，值为整数，只要在short范围即可
short s = 12345;
System.out.println(s);
// 整数的默认类型就是int类型
int num = 654321;
System.out.println(num);
// 定义long类型的整数，需要在数据的后面加字母（L），大小写不限，建议大写。
long lo = 123456789L;
System.out.println(lo);
// 定义float类型的浮点数，需要在数据的后面加字母（F），大小写不限，建议大写。
float f = 1.5F;
System.out.println(f);
// 浮点型默认类型double
double d = 123.456;
System.out.println(d);
// 布尔型只有两个取值：true和false
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);
System.out.println(b2);
// 定义字符型需要一对英文的单引号包裹，并且只能包含一个字符
char c = 'a';
System.out.println(c);
}
}题目10（代码题）
请根据下列描述，选用合适的数据类型定义变量，并输出变量的值。
1、班级里有100个学员。
2、某商品价格55.55元。
3、地球已经诞生超过46亿年。
4、“5是偶数”这句话的描述是假的。
输出结果如下：
100
55.55
4600000000
false训练目标
变量的定义
训练提示
1、不同的数据信息需要使用不同的数据类型，可以根据不同数据类型的大小以及特点选择合适的类型来定义变量，描述事物的信息。
参考方案
定义变量描述信息。
训练步骤
1、创建java文件，定义类Test04，编写主方法。
2、在主方法中定义不同的变量描述题目中的信息。
2.1、学员数量，可以用默认的整数类型int表示
2.2、商品价格，使用默认的浮点数类型double表示
2.3、天文数字，可以使用长整型long表示
2.4、一个描述真或者假，只有两种状态，可以使用boolean类型
3、使用输出语句，输出变量。
4、编译并运行，查看输出结果。
参考答案
public class Test02 {
public static void main(String[] args) {
int studentNumber = 100; // 学生数量
System.out.println(studentNumber);
double price = 55.55; // 商品价格
System.out.println(price);
long yearNumber = 4600000000L; // 超出int范围的整数
System.out.println(yearNumber);
boolean flag = false; // 真假值
System.out.println(flag);
}
}题目11（代码题）
在今天的课程学习中，我们知道了java的8种基本数据类型，随着后续学习，我们还将学习引用数据类型。此时由于练习需要，我们要了解其中一个最常用的引用数据类型-字符串（String），字符串变量的一种定义方式与基本数据类型一致：
// 数据类型 变量名 = 初始化值；
String str = "中国";
System.out.println(str);
// 其中String为数据类型，str为变量名（符合标识符规则即可），"中国"是我们学习的字符串常量值。
// 总体即表示：将字符串"abc"，赋值给字符串类型的变量str。
// 输出结果为：中国请根据以上描述，选用合适的数据类型定义变量用于描述一个学员的信息，并将其输出到屏幕上。输出结果如下：
************************
我的姓名是：张三
我的性别是：男
我的年龄是：18
我的地址是：xx省xx市
我的饭卡余额是：55.55元
************************训练目标
数据类型、变量的定义和使用、字符串连接符
训练提示
1、根据题目要求，学员的信息包含姓名、性别、年龄、地址、余额，这些信息分别应该使用什么样的数据类型来存储呢？
2、在输出语句中，为了按照题目要求的格式输出，需要将一些已知字符串和变量进行拼接，比如：“我的姓名是：” + name
参考方案
训练步骤
1、创建java文件，定义类Test03，编写主方法。
2、在主方法中定义变量用于存储学员信息。
2.1、姓名、性别、地址都可以使用字符串类型
2.2、年龄为整数数据，使用int类型
2.3、余额为小数类型，使用double类型
3、将已知字符串与变量使用“+”拼接在一起输出。
4、保存文件，编译运行，查看结果。
参考答案
public class Test03 {
public static void main(String[] args) {
// 姓名
String name = "张三";
// 性别
String gender = "男";
// 年龄
int age = 20;
// 地址
String address = "美国芝加哥";
// 余额
double money = 88.88;
System.out.println("************************");
System.out.println("我的姓名是：" + name); // 在输出语句中将变量与字符串拼接
System.out.println("我的性别是：" + gender);
System.out.println("我的年龄是：" + age);
System.out.println("我的地址是：" + address);
System.out.println("我的饭卡余额是：" + money + "元");
System.out.println("************************");
}
}JavaSE 03 作业讲解和答案
知识点
运算符
题目1(训练)
身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下：
儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？
训练提示
- 已知的父母身高如何用代码体现？
- 题目中的公式如何转化为代码？
解题方案
- 使用变量的定义和算术运算符完成本题
操作步骤
- 定义小数变量代表父亲身高
- 定义小数变量代表母亲身高
- 通过儿子身高计算方式计算儿子身高
- 通过女儿身高计算方式计算女人身高
参考答案
public class Demo01 {
public static void main(String[] args) {
//1.定义父亲身高
double father = 177;
//2.定义母亲身高
double mother = 165;
//3.利用公式计算儿子身高
double son = (father + mother) * 1.08 / 2;
//4.利用公式计算女儿身高
double daughter = (father * 0.923 + mother) / 2;
//5.打印结果
System.out.println("儿子预计身高" + son + "厘米");
System.out.println("女儿预计身高" + daughter + "厘米");
}
}题目2（训练）
红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？
训练提示
- 用什么知识点来计算她们现在的钱有多少？
- 如何对比两个人的钱数？
解题方案
- 使用赋值运算符和算术运算符计算各自的钱，使用比较运算符对比大小
操作步骤
- 定义红茶妹妹原来的钱为整数变量
- 定义绿茶妹妹原来的钱为整数变量
- 使用赋值运算符和算术运算符计算其现有的钱
- 使用比较运算符对数值做出比较
参考答案
public class Demo2 {
public static void main(String[] args) {
//1.定义红茶妹妹原来的钱
int red = 21;
//2.定义绿茶妹妹原来的钱
int green = 24;
//3.求红茶妹妹现有的钱
red = red * 2 + 3;
//4.求绿茶妹妹现有的钱
green *= 2;
//5.判断并输出两个人的钱是否相等
System.out.println(red == green);
}
}题目3（综合）
某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？
训练提示
- 有两种购买方式，一种是不使用优惠价，另一种是使用优惠价。分别计算花费后，对两种方式的花费作对比。
解题方案
- 使用算术运算符、赋值运算符和三元运算符联合完成本题
操作步骤
- 使用算术运算符求出不使用优惠时的总价
- 使用三元运算符判断总价是否满足打折条件，并求出折后总价
- 使用算术运算符求出使用优惠价时的总价
- 使用三元运算符判断最终更合算的购买方式和花费
参考答案
public class Demo3 {
public static void main(String[] args) {
//1.求不使用优惠时的总价
double money1 = 24 + 8 + 3;
//2.判断折后总价
money1 = (money1 >= 30 ? money1 * 0.8 : money1);
//3.求使用优惠时的总价
double money2 = 16 + 8 + 3;
//4.判断两种花费哪个更少
double money = money1 < money2 ? money1 : money2;
//5.打印最终花费
System.out.println(money);
}
}题目4
看代码说结果，不要去运行。
System.out.println(2.0*(5/2));
- 4
- 4.0
- 5
- 5.0
- 以上答案都不对
讲解：
答案：4.0
在Java中整数相除结果为整数，所以5/2结果是2
2.0乘以2，结果就是4.0
题目5：
看代码说结果，不要去运行。
String firstName = "Tomas";
String familyName = "Zhang";
打印firstName + familyName 之后是什么结果？
"TomasZhang"
因为字符串相加其实是进行拼接操作题目6：
需求：
数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出true。
如果它们的和为6的倍数。最终结果输出true。
其他情况都是false。请参见视频
题目7：
需求：
键盘录入一个三位数，求这个三位数每一位的数字和。
举例：
键盘录入123。那么每一位数字相加为：1 + 2 + 3，和为：7。
代码示例：
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
int sum = ge + shi + bai;
System.out.println(sum);
}
}JavaSE 04 作业讲解和答案
一、if 判断语句作业
题目1
李雷想买一个价值7988元的新手机，她的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新的优惠，把她的旧手机交给店家，新手机就能够打8折优惠。为了更省钱，李雷要不要以旧换新？请在控制台输出。
训练提示
- 用什么知识点能够对不同购买方式的价格做判断？
解题方案
- 使用if…else语句判断
操作步骤
- 计算不使用以旧换新时的花费。
- 计算使用以旧换新时的花费。
- 使用if…else语句判断哪种方式更省钱，并输出结果
参考答案
public class Demo1 {
public static void main(String[] args) {
//1.计算不使用以旧换新的花费
int money1 = 7988 - 1500;
//2.计算以旧换新的花费
double money2 = 7988 * 0.8;
//3.判断两种方式
if(money1 > money2){
System.out.println("使用以旧换新更省钱");
}else{
System.out.println("不使用以旧换新更省钱");
}
}
}题目2
让用户依次录入三个整数，求出三个数中的最小值，并打印到控制台。
训练提示
- 如何完成用户录入？
- 求最小值需要用到什么知识点？
解题方案
- 使用Scanner键盘录入三个数字，使用三元运算符实现
- 使用Scanner键盘录入三个数字，使用if…else的嵌套实现（不做要求）
操作步骤
- 使用三次键盘录入的方法让用户输入三个整数
- 使用三元运算符求出最小值
- 打印输出最小值
备注：
本题，也可以使用if嵌套的方式书写，但是非常麻烦，建议用三元运算符。
可以自己试着写一下if嵌套方式，然后跟三元运算符方式进行对比一下，看看谁更简单。
参考答案
//1.导包
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
//2.创建键盘录入对象
Scanner sc = new Scanner(System.in);
//3.分别录入三个数字
System.out.println("请输入第一个整数：");
int i = sc.nextInt();
System.out.println("请输入第二个整数：");
int j = sc.nextInt();
System.out.println("请输入第三个整数：");
int k = sc.nextInt();
//4.定义变量代表最小值
int min;
//5.对三个整数进行判断
if( i < j && i < k){
min = i;
}else if( j < i && j < k){
min = j;
}else{
min = k;
}
//6.打印最小值
System.out.println("最小值是" + min);
}
}题目3（一般难度）
某银行推出了整存整取定期储蓄业务，其存期分为一年、两年、三年、五年，到期凭存单支取本息。存款年利率表如下：
存期 年利率（%）
一年 2.25
两年 2.7
三年 3.25
五年 3.6
请存入一定金额（1000起存），存一定年限（四选一），计算到期后得到的本息总额。
提示：
存入金额和存入年限均由键盘录入
本息计算方式：本金+本金×年利率×年限
训练提示
- 使用什么方式让用户输入内容？
- 使用哪种if语句的格式对信息作出判断？
解题方案
- 使用Scanner和if…else…的嵌套操作。
操作步骤
- 键盘录入金额和年份。
- 使用多条件if…else判断年份，计算本息金额。
- 输出结果。
参考答案
//1.导包
import java.util.Scanner;
public class Demo3 {
public static void main(String[] args) {
// 2.创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3.调用方法获取键盘录入的本金和存取年限
System.out.println("请输入存款金额：");
int money = sc.nextInt();
System.out.println("请输入存款年限：");
int year = sc.nextInt();
// 4.定义本息和的变量
double outMoney = 0;
// 5.根据利率和年限计算本息和
if (year == 1) {
outMoney = money + money * 2.25 / 100 * 1;
} else if (year == 2) {
outMoney = money + money * 2.7 / 100 * 2;
} else if (year == 3) {
outMoney = money + money * 3.25 / 100 * 3;
} else if (year == 5) {
outMoney = money + money * 3.6 / 100 * 5;
} else {
System.out.println("输入的年限有误");
}
// 6.打印输出
System.out.println("存款" + year + "年后的本息是：" + outMoney);
}
}题目4（较难）
某商场购物可以打折，具体规则如下：
普通顾客购不满100元不打折，满100元打9折；
会员购物不满200元打8折，满200元打7.5折；
不同打折规则不累加计算。
请根据此优惠计划进行购物结算，键盘录入顾客的类别（0表示普通顾客，1表示会员）和购物的折前金额（整数即可），输出应付金额（小数类型）。
训练提示
- 使用什么方式让用户输入内容？
- 使用哪种if语句的格式对信息作出判断？
解题方案
- 使用Scanner键盘录入和if…else判断语句的嵌套使用来完成。
操作步骤
- 键盘录入会员类别和购物金额。
- 先使用if-else判断顾客类别。
- 在不同的顾客类别中再使用if-else语句判断购物金额。
- 输出结果。
参考答案
//1.导包
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
// 2.创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3.调用方法获取键盘录入的顾客类别和购物金额
System.out.println("请输入顾客类别（0表示普通顾客，1表示会员顾客）：");
int type = sc.nextInt();
System.out.println("请输入购物金额：");
int money = sc.nextInt();
// 4.先判断顾客类别
if (type == 0) {
// 4.1.普通顾客，再判断购物金额
if (money > 0 && money < 100) {
System.out.println("您的应付金额为：" + money);
} else if (money >= 100) {
System.out.println("您的应付金额为：" + money * 0.9);
} else {
System.out.println("您输入的金额有误");
}
} else if (type == 1) {
// 4.2.会员顾客，再判断购物金额
if (money > 0 && money < 200) {
System.out.println("您的应付金额为：" + money * 0.8);
} else if (money >= 200) {
System.out.println("您的应付金额为：" + money * 0.75);
} else {
System.out.println("您输入的金额有误");
}
} else {
System.out.println("您输入的顾客类别有误");
}
}
}题目5（很难）
2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
0 ~ 3000元的部分，交税3%
3000 ~ 12000元的部分，交税10%
12000 ~ 25000的部分 ， 交税20%
25000 ~ 35000的部分，交税25%
35000 ~ 55000的部分，交税30%
55000 ~ 80000的部分，交税35%
超过80000的部分，交税45%
比如：黑马某学员入职一家企业后，税前工资是15000，则他每月该交个税的部分是15000-1500-5000=8500元，个税缴纳数额是3000×3%+5500×10%=640元。税后工资12860元。
请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？
训练提示
- 工资的哪些部分是属于要纳税部分，如何计算？
- 纳税比例有很多区间，用什么知识点能够对应多个区间？
- 每个区间的纳税数额是多少，计算的规律是什么？
解题方案
- 使用多条件的if…else对应各个纳税梯度，分别计算每一个梯度的纳税数额。
操作步骤
- 提示用户输入税前工资，使用键盘录入让用户输入一个整数。
- 计算工资中应交税部分。也就是去除三险一金和起征点数额。
- 使用多条件if…else…对每个区间分别判断，用每个梯度的计算公式求出对应的纳税数额。
- 根据求出的纳税数额求出税后工资。
参考答案
//1.导包
import java.util.Scanner;
public class Demo5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的税前工资：");
//2.键盘录入税前工资
int money = sc.nextInt();
//3.计算应纳税部分的工资
double before = money - (money*0.1) - 5000;
//4.定义个税变量
double shui = 0;
//5.按照梯度范围计算个税数值
if(before > 0 && before <=3000){
shui = before * 0.03;
}else if(before > 3000 && before <=12000){
shui = 3000*0.03 + (before-3000) * 0.1;
}else if(before > 12000 && before <=25000){
shui = 3000*0.03 + 9000*0.1 + (before-12000)*0.2;
}else if(before > 25000 && before <=35000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + (before-25000)*0.25;
}else if(before > 35000 && before <=55000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + (before-35000)*0.3;
}else if(before > 55000 && before <=80000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + (before-55000)*0.35;
}else if(before > 80000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + 25000*0.35 + (before-80000)*0.45;
}
//6.计算税后工资
double after = money - (money*0.1) - shui;
//7.打印个税和税后工资
System.out.println("个人所得税" + shui + "元");
System.out.println("税后工资" + after + "元");
}
}二、switch选择语句作业
题目1
模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果。
要求：
键盘录入三个整数,其中前两个整数代表参加运算的数据，第三个整数为要进行的运算(1:表示加法运算,2:表示减法运算,3:表示乘法运算,4:表示除法运算)，演示效果如下:
请输入第一个整数: 30
请输入第二个整数: 40
请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法): 1
控制台输出:30+40=70
训练提示
- 用户录入了数据之后，用什么知识点去判断加减乘除四种不同的操作？
解题方案
- 使用switch判断语句完成。
操作步骤
- 使用键盘录入三个变量。
- 使用switch判断语句对第三个变量进行判断，匹配要执行的操作。
- 在每一个case中分别对第一个变量和第二个变量进行不同的操作。
参考答案
// 1.导包
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
// 2.创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3.提示需要输入的数据，并调用方法获取输入的数据
System.out.println("请输入第一个整数：");
int num1 = sc.nextInt();
System.out.println("请输入第二个整数：");
int num2 = sc.nextInt();
System.out.println("请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法)");
int type = sc.nextInt();
// 4.使用switch语句判断计算类型，并输出相应的结果
switch (type) {
case 1:
System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
break;
case 2:
System.out.println(num1 + " - " + num2 + " = " + (num1 - num2));
break;
case 3:
System.out.println(num1 + " * " + num2 + " = " + (num1 * num2));
break;
case 4:
System.out.println(num1 + " / " + num2 + " = " + (num1 * 1.0 / num2));
break;
default:
System.out.println("您输入的运算类别有误");
break;
}
}
}三、循环语句作业
题目1
键盘录入两个数字number1和number2表示一个范围，求这个范围之内的数字和。
训练提示
- number1和number2不知道谁大谁小，需要先判断大小关系
- 确定大小之后，可以循环得到范围里面的每一个数
- 把每一个数字进行累加即可
参考答案
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//键盘输入两个数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字");
int number1 = sc.nextInt();
System.out.println("请输入第二个数字");
int number2 = sc.nextInt();
//获取最大值和最小值
int max = number1 > number2 ? number1 : number2;
int min= number1 < number2 ? number1 : number2;
//累加求和
int sum = 0;
for (int i = min; i <= max; i++) {
sum = sum + i;
}
System.out.println(sum);
}
}题目2
需求：
键盘录入两个数字，表示一个范围。统计这个范围中。既能被3整除，又能被5整除数字有多少个？
训练提示
- 需要先判断键盘录入两个数字的大小关系
- 确定大小之后，可以循环得到范围里面的每一个数
- 找到一个符合条件的数字，统计变量就自增一次
操作步骤
- 确定键盘录入的两个数字大小关系
- 定义for循环，找到范围之内的每一个数字
- 对每一个数字进行判断
- 符合条件统计变量自增一次
参考答案
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//键盘输入两个数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字");
int number1 = sc.nextInt();
System.out.println("请输入第二个数字");
int number2 = sc.nextInt();
//获取最大值和最小值
int max = number1 > number2 ? number1 : number2;
int min= number1 < number2 ? number1 : number2;
//统计个数
int count = 0;
for (int i = min; i <= max; i++) {
if(i % 3 == 0 && i % 5 == 0){
count++;
}
}
System.out.println(count);
}
}题目3
需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，
假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
参考答案
参见视频题目4
需求：给你一个整数 x 。
如果 x 是一个回文整数，打印 true ，否则，返回 false 。
解释：回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。
参考答案
参见视频题目5
需求：
给定两个整数，被除数dividend和除数divisor（都是正数，且不超过int的范围） 。
将两数相除，要求不使用乘法、除法和 % 运算符。
得到商和余数。
参考答案
参见视频题目6（较难）
已知2019年是猪年，请在控制台输出从1949年到2019年中所有是猪年的年份。
训练提示
- 1949到2019有很多年？逐个判断这么多年份肯定要用循环。
- 用什么条件来判断是否是猪年？
解题方案
- 使用for循环逐年判断，根据2019是猪年这个条件，使用if来判断其他是猪年的年份。
操作步骤
- 定义for循环，1949到2019的年份是循环次数。
- 对每个年份逐个判断，如果年份和2019的差值是12的倍数，说明这年是猪年
- 打印符合条件的年份
参考答案
public class Demo1 {
public static void main(String[] args) {
//1.循环开始是1949 结束是2019
for (int i = 1949; i < 2019; i++) {
//2.如果年份和2019年的差值是12的倍数 则说明是猪年
if( (2019 - i) % 12 == 0 ){
//3.打印符合条件的年份
System.out.println(i);
}
}
}
}题目7（较难）
中国有闰年的说法。闰年的规则是：四年一闰，百年不闰，四百年再闰。（年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年）。请打印出1988年到2019年的所有闰年年份。
训练提示
- 从1988年到2019年有很多年，每年都需要判断，用什么知识点对每年进行判断？
解题方案
- 使用while循环完成
- 使用for循环完成
以下以方案2为准
操作步骤
- 定义for循环，循环开始是1988，结束是2019
- 在循环中对年份进行判断
- 如果符合闰年的判断条件，则打印该年份
参考答案
public class Demo2 {
public static void main(String[] args) {
//1. 定义对年份的循环
for (int year = 1988; year <= 2019; year++) {
//2. 判断当年是否符合闰年条件
if((year%4 == 0 && year%100 != 0) || year%400 == 0){
System.out.println(year + "是闰年");
}
}
}
}JavaSE 05 作业讲解和答案
知识点
数组
题目1
请创建一个长度为6的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：
数组为：{1,2,3,4,5}
打印结果：1 2 3 4 5训练提示
1、数组中的元素有索引，开始索引和结束索引分别是什么？使用循环语句，依次通过索引获取元素即可遍历数组。
2、在打印数组元素时，是以空格分隔，并且不换行，该怎样输出？
解题方案
for循环遍历数组
操作步骤
1、定义int数组，使用静态初始化方式为元素赋值。
2、使用for循环对数组进行遍历，循环索引从0开始，到数组的长度-1结束。
3、逐个打印数组元素，打印元素不换行，在输出元素的后面拼接空格。
参考答案
public class Demo1 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {11,22,33,44,55};
//2.对数组遍历
for (int i = 0; i < arr.length; i++) {
//3.打印每一个元素
System.out.print(arr[i] + " ");
}
}
}题目2
现有一个小数数组{12.9, 53.54, 75.0, 99.1, 3.14}。请编写代码，找出数组中的最小值并打印。
训练提示
1、数组的元素是小数，需要定义小数类型数组。
2、找最值需要先定义一个参考值，然后依次拿每个值与参考值比较即可。
解题方案
将数组的第一个值作为参考值，遍历数组，依次比较，记录更小值。
操作步骤
1、定义double类型数组并存入元素。
2、定义double类型变量min代表最小值，初始化为数组第一个值。
3、遍历数组，用每个元素依次和变量min对比。
4、如果发现有元素小于min，则把该元素赋值给min。
5、遍历结束之后min记录的就是最小值，打印结果。
参考答案
public class Demo2 {
public static void main(String[] args) {
//1.定义数组
double[] arr = {12.9,53.54,75.0,99.1,3.14};
//2.定义变量代表最小值
double min = arr[0];
//3.对数组遍历
for (int i = 1; i < arr.length; i++) {
//4.判断
if(arr[i] < min){
min = arr[i];
}
}
//4.打印最小值
System.out.println("最小值是" + min);
}
}题目3
创建一个长度为6的整数数组。请编写代码，随机生成六个0（包含）-100（不包含）之间的整数存放到数组中，然后计算出数组中所有元素的和并打印。
训练提示
1、数组有6个元素，那么就要生成6次随机数。
2、要求所有元素的和，首先需要定义变量来存储求和结果，然后再获取所有元素，依次累加就可以了。
解题方案
定义求和变量，遍历数组，累加元素值。
操作步骤
1、定义长度为6的int数组。
2、创建随机数Random类对象。
3、遍历数组，在循环中生成随机数并给数组元素赋值。
4、定义求和变量，初始化值为0。
5、遍历数组，获取每一个元素，累加。
6、遍历结束，打印结果。
参考答案
public class Demo3 {
public static void main(String[] args) throws IOException {
//1.创建随机数对象
Random r = new Random();
//2.定义长度为6的数组
int[] arr = new int[6];
//3.循环给数组赋值
for (int i = 0; i < arr.length; i++) {
int num = r.nextInt(100);
arr[i] = num;
}
//4.定义求和变量
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
//5.打印结果
System.out.println("和是" + sum);
}
}题目4
现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。例如：
数组：{2, 1, 3, 5, 4}
表示的整数为：21354 // 注：是整数类型的两万一千三百五十四，不是字符串拼起来的。训练提示
1、首先肯定要获取数组的每一个元素，需要遍历。
2、根据题目分析，个位元素本身就可以表示值，十位是元素乘以10来表示值，百位就是元素乘以100来表示值。。。它们之间有什么规律呢？从左至右，每一位所表示的值是下一位的十倍。根据此规律，怎样编写算法实现呢？
解题方案
遍历数组，与求和的思路相似，但算法不同，累加时需要将高位*10再累加。
操作步骤
1、定义int类型数组，使用静态初始化，将数字存入数组。
2、定义变量num用来存储最终的数值。
3、对数组进行遍历，遍历开始索引是0，结束索引是arr.length-1。
4、在循环中，把num的值乘10再加上元素的值，赋值给num变量。
5、循环上面的步骤，num的值即为所求，打印结果。
参考答案
public class Demo4 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1, 3, 5, 7, 9};
//2.定义变量存储最终的整数
int num = 0;
//3.对数组进行遍历
for (int i = 0; i < arr.length; i++) {
//4.计算，高位乘以10再加上当前位的值
num = num * 10 + arr[i];
}
//5.打印结果
System.out.println(num);
}
}题目5
定义一个数组来存储10个学生的成绩，例如：{72, 89, 65, 87, 91, 82, 71, 93, 76, 68}。计算并输出学生的平均成绩。
训练提示
1、要操作数组的每一个元素，需要遍历。
2、怎样求平均数？其实只要求和之后也就知道了平均数。
解题方案
使用数组的遍历操作完成。
操作步骤
- 定义保存学生成绩的数组arr。
- 定义变量sum用来存储和。
- 对数组进行遍历，求和。
- 和除以元素个数得到平均数。
- 打印结果。
参考答案
public class Demo5 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {72,89,65,87,91,82,71,93,76,68};
//2.定义变量存储累加和
double sum = 0;
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
//4.通过和求出平均数
double avg = sum / arr.length;
//5.打印平均数
System.out.println("平均值是" + avg);
}
}题目6（很难）
有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下：
请输入一个整数数字：
50
生成的新数组是：12 14 23 45 50 66 68 70 77 90 91训练提示
- 数组的长度是不能改变的，所以增加一个元素需要定义一个新数组。
- 数组元素是从小到大排列的，如何找到新元素存放的位置？
解题方案
使用数组的遍历，用元素依次和数字作比较，找到正确的存放位置。
操作步骤
- 定义原数组arr，和一个比原数组长度大1的新数组brr。
- 通过键盘录入的方式输入变量num的值。
- 定义变量index用于记录num存放的索引位置。
- 遍历数组，小于或等于num的元素直接存放到原来的位置，大于num的元素往后移动一个位置。
- 存放结束之后，中间会空出一个位置,在遍历时用index记录这个位置。把num放在这个索引处。
- 最终遍历新数组打印结果。
参考答案
public class Demo6 {
public static void main(String[] args) {
//1.定义长度为10的原数组
int[] arr = {12,14,23,45,66,68,70,77,90,91};
//2.定义长度为11的空数组
int[] brr = new int[11];
//3.键盘录入数组
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数数字");
int num = sc.nextInt();
//4.定义变量代表要插入的位置
int index = 0;
//5.循环遍历原数组
for (int i = 0; i < arr.length; i++) {
if(arr[i] <= num) {
//5.1如果元素小于等于要插入的数字，则直接存放
brr[i] = arr[i];
//5.2把i后面的位置记录下来
index = i + 1;
}else{
//5.3如果元素大于要插入的数字,则往后一个位置存放
brr[i+1] = arr[i];
}
}
//6.index存储的就是要插入的位置
brr[index] = num;
//7.遍历新数组查看结果
System.out.print("生成的新数组是：");
for (int i = 0; i < brr.length; i++) {
System.out.print(brr[i] + " ");
}
}
}题目7（很难）
定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）
训练提示
- 要找奇数和偶数只需要判断对2取余即可。
- 找到一个奇数或偶数之后，把它放在哪个索引处？
解题方案
- 定义一个新数组。把原数组的奇数放在新数组的左边，把原数组的偶数放在新数组的右边。
- 不定义新数组。找到左边的偶数，和右边的奇数互换位置。
以下以方案1为准
操作步骤
- 定义出原数组arr，其中包含多个数字。
- 定义新数组brr，和arr的长度一样。
- 定义变量left，初始值是0准备从左边放元素，定义变量right，初始值是arr.length-1准备从右边放元素。
- 对原数组arr进行遍历。
- 如果元素是奇数，则放在新数组brr的左边，left变量加一。
- 如果元素是偶数，则放在新数组brr的右边，right变量减一。
- 遍历新数组brr打印最终结果。
参考答案
public class Demo8 {
public static void main(String[] args) {
//1.定义原数组
int[] arr = {12,23,34,45,67,78,11,22};
//2.定义空数组
int[] brr = new int[arr.length];
//3.定义变量代表奇数要存放的位置
int left = 0;
//4.定义变量代表偶数要存放的位置
int right = arr.length-1;
//5.对原数组进行遍历
for (int i = 0; i < arr.length; i++) {
if(arr[i] % 2 == 1){
//5.1如果是奇数就往左边放
brr[left] = arr[i];
//5.2存放之后让索引向右移动
left++;
}else{
//5.3如果是偶数就往右边放
brr[right] = arr[i];
//5.4存放之后让索引向左移动
right--;
}
}
//6.打印brr数组
for (int i = 0; i < brr.length; i++) {
System.out.print(brr[i] + " ");
}
}
}JavaSE 06 作业讲解和答案
知识点
方法
题目1
定义一个方法，该方法能够找出两个小数中的较小值并返回。在主方法中调用方法进行测试。
训练提示
- 根据方法的功能描述，方法的参数应该是两个小数。
- 要返回两个小数的较小值，所以返回值类型也是小数类型。
解题方案
操作步骤
- 定义方法getMin()，方法的参数是double a ，double b。
- 在方法中对两个数字进行判断，返回较小值。
- 在主方法中调用getMin()方法并接受返回值。
- 在主方法中打印结果。
参考代码
public class Test1 {
public static void main(String[] args) {
System.out.println(getMin(2.1,3.7));
}
public static double getMin(double a, double b) {
double min = a < b ? a : b;
return min;
}
}题目2
定义一个方法，该方法能够找出三个整数中的最大值并返回。在主方法中调用方法测试执行。
训练提示
- 根据题意，方法中需要使用三个整数，所以方法参数应该是三个整数类型。
- 方法需要有返回值，返回值的类型也是整数类型。
解题方案
操作步骤
- 定义方法getMax()，方法的参数是三个int类型变量a,b,c，方法的返回值是int类型。
- 在方法中使用多分支if…else…或者三元运算符判断出最大值并返回。
- 在主方法中调用getMax()方法并接受返回值。
- 在主方法中打印结果。
参考代码
public class Test1 {
public static void main(String[] args) {
System.out.println(getMax(3,17,10));
}
public static int getMax(int a, int b, int c) {
int temp = a > b ? a : b;
int max = temp > c ? temp : c ;
return max;
}
}
public class Test2 {
public static void main(String[] args) {
System.out.println(getMax(3, 17, 10));
}
public static int getMax(int a, int b, int c) {
if (a > b) {
//a 大
//拿着大的跟第三个数再比较
if(a > c){
return a;
}else{
return c;
}
}else{
//b 大
if(b > c){
return b;
}else{
return c;
}
}
}
}题目3
在主方法中通过键盘录入三个整数。定义一个方法，方法接收三个整数变量，在方法中从大到小依次打印三个变量。执行效果如下：
请输入第一个整数：10
请输入第二个整数：30
请输入第三个整数：20
从大到小的顺序是： 30 20 10训练提示
- 方法需要接受三个整数，那么方法的形式参数如何定义？
- 方法没有返回值的需求，返回值类型是什么？
解题方案
操作步骤
- 使用键盘录入分别录入三个整数。
- 定义method方法，方法的参数是三个int类型，方法的返回值类型是void。
2.1. 定义整数变量max用于存储最大值，定义min变量用于存储最小值。
2.2. 使用if…else…多分支判断语句或者三元运算符计算三个整数中的最大值并赋值给max。
2.3. 使用if…else…多分支判断语句或者三元运算符计算三个整数中的最小值并赋值给min。
2.4. 定义变量mid代表中间数,三个整数的和减去max,再减去min,就是中间数的值。
2.5. 依次打印最大值，中间值和最小值。 - 在主方法中调用method方法，传入参数。
参考答案
public class Test5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数");
int num1 = sc.nextInt();
System.out.println("请输入第二个数");
int num2 = sc.nextInt();
System.out.println("请输入第三个数");
int num3 = sc.nextInt();
//获取最大值
int max = getMax(num1, num2, num3);
//获取最小值
int min = getMin(num1, num2, num3);
//获取中间值
int mid = (num1 + num2 + num3) - max - min;
System.out.println(max + " " + mid + " " + min);
}
public static int getMax(int a, int b, int c) {
int temp = a > b ? a : b;
int max = temp > c ? temp : c;
return max;
}
public static int getMin(int a, int b, int c) {
int temp = a < b ? a : b;
int min = temp < c ? temp : c;
return min;
}
}题目4
数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。
训练提示
- 方法的功能是得到一个小数的绝对值，参数应该是一个小数类型。
- 绝对值需要被返回，返回值类型应该也是小数类型。
解题方案
操作步骤
- 定义一个小数变量num。
- 定义获取绝对值的方法，方法的参数是一个double类型，返回值类型是double。
- 在方法内部使用if…else…判断。
3.1. 如果是负数则对负数取反并返回。
3.2. 如果不是负数则直接返回数字本身。 - 在主方法中调用绝对值方法，传入参数num,并接受返回值。
- 打印返回的结果。
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目5
键盘录入一个正整数
定义一个方法,该方法的功能是计算该数字是几位数字,并将位数返回
在main方法中打印该数字是几位数
演示格式如下:
(1)演示一:
请输入一个整数:1234
控制台输出:1234是4位数字
(2)演示二:
请输入一个整数:34567
控制台输出:34567是5位数字
训练提示
- 方法的功能是求有多少位，所以参数是一个，就是要计算的数据。
- 题目说要返回，所以方法必须有返回值。
解题方案
操作步骤
- 键盘录入一个正整数
- 定义获取位数的方法，方法的参数是一个int类型，返回值类型是int。
- 在方法内部使用循环获取有多少位
可以不断的除以10，当结果为0时，循环结束。
除以10的次数，就是数字的位数。
举例：
123 除以第一次10之后为：12
除以第二次10之后为：1
除以第三次10之后为：0
表示123是三位数 - 在主方法中调用方法，传入参数,并接受返回值。
- 打印返回的结果。
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目6
需求：
定义一个方法equals(int[] arr1,int[] arr2).
功能：
比较两个数组是否相等（长度和内容均相等则认为两个数组是相同的）
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目7：
需求：
定义一个方法fill(int[] arr,int value)
功能：
将数组arr中的所有元素的值改为value
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目8：（较难）
需求：
定义一个方法fill(int[] arr,int fromIndex,int toIndex,int value)
功能：
将数组arr中的元素从索引fromIndex开始到toIndex（不包含toIndex）对应的值改为value
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目9：（较难）
需求：
定义一个方法copyOf(int[] arr, int newLength)
功能：
将数组arr中的newLength个元素拷贝到新数组中，并将新数组返回，从索引为0开始
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目10：（较难）
需求：
定义一个方法copyOfRange(int[] arr,int from, int to)
功能：
将数组arr中从索引from（包含from）开始，到索引to结束（不包含to）的元素复制到新数组中，
并将新数组返回。
参考答案
本题有点意思，能否自己思考一下，不懂的可以在评论区或者群里问其他小伙伴哟~题目11（很难）
一个大V直播抽奖，奖品是现金红包，分别有{2,588,888,1000,10000}五个奖金。请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：（随机顺序，不一定是下面的顺序）
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出训练提示
- 奖项要随机出现，但奖金不是连续的数字，不能被随机产生。能随机产生的只有数组的索引了，可以使用随机索引来代表随机元素。因为索引和元素是一一对应的，
- 哪些奖被抽过了，哪些奖没有被抽过，要定义一个数组来存放已经被抽过的奖项。
- 每个奖项只能被抽出一次，要写一个方法来控制奖项不重复。
解题方案
使用数组存放多个奖金，再使用另一个数组存放已经被抽过的奖金，使用方法来判断某个奖金是否已经被抽取过。
操作步骤
- 定义奖金的数组arr。
- 定义数组brr准备存放已经被抽过的奖金，两个数组长度相同。
- 定义一个变量index,用户代表数组brr的索引。
- 定义方法，判断数组中是否存在某数字，存在返回true,不存在返回false。
- 写一个while循环，如果index<arr.length则说明奖项没有被抽完继续抽取。
- 在循环中使用随机数产生一个随机索引i。
- 使用步骤4的方法判断brr数组中是否包含arr[i]奖金。
- 如果不包含，则打印arr[i]奖金，并且把它放入brr数组中代表已经被抽取过，同时index加一。
参考答案
本题为后一天的课堂练习，不会的小伙伴可以看视频哟~JavaSE 07 作业讲解和答案
知识点
面向对象
题目1（完成）
定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。
请定义出手机类，类中要有空参、有参构造方法，set/get方法。
定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。
调用对象的两个功能，打印效果如下：
正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
解题方案
操作步骤
- 定义手机类，手机类中定义String类型的品牌，int类型的价格，String类型的颜色，三个成员变量都用privice修饰。
- 提供空参构造方法和有参构造方法。
- 提供set/get方法。
- 编写打电话的成员方法，方法中对成员变量进行使用。
- 编写发短信的成员方法，方法中对成员变量进行使用。
- 在测试类中创建手机对象，使用set方法赋值，分别调用各个方法。
参考答案
题目2（完成）
定义一个女朋友类。女朋友的属性包含：姓名，身高，体重。行为包含：洗衣服wash()，做饭cook()。另外定义一个用于展示三个属性值的show()方法。请在测试类中通过有参构造方法创建对象并赋值，然后分别调用展示方法、洗衣服方法和做饭方法。打印效果如下：
我女朋友叫凤姐,身高155.0厘米,体重130.0斤
女朋友帮我洗衣服
女朋友给我做饭训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
- 展示方法的作用就是打印姓名、身高、体重三个成员变量的值。
解题方案
操作步骤
- 定义女朋友类，定义String类型姓名，double类型身高和double类型体重三个成员变量，三个成员变量都用privice修饰。
- 提供空参构造方法和有参构造方法。
- 提供set/get方法。
- 编写展示方法show()，方法打印三个成员变量的值。
- 编写洗衣服wash()方法，输出洗衣服的语句。
- 编写做饭cook()方法，输出做饭的语句。
- 在测试类中使用有参构造创建女友对象，分别调用各个方法。
参考答案
题目3（完成）
定义项目经理类Manager。属性：姓名name，工号id，工资salary，奖金bonus。行为：工作work()
定义程序员类Coder。属性：姓名name，工号id，工资salary。行为：工作work()
要求：
1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:
工号为123基本工资为15000奖金为6000的项目经理张三正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员李四正在努力的写着代码......训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
- 在工作work()方法中调用成员变量，输出成员变量的值。
解题方案
操作步骤
- 定义项目经理类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id,salary,bonus的值。
- 定义程序猿类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id和salary的值。
- 在测试类中使用有参构造创建项目经理对象并赋值，调用工作方法打印结果。
- 在测试类中使用有参构造创建程序员对象并赋值，调用工作方法打印结果。
参考答案
题目4（完成）
定义猫类Cat。属性:毛的颜色color，品种breed。行为:吃饭eat()，抓老鼠catchMouse()
定义狗类Dog。属性:毛的颜色color，品种breed。行为:吃饭()，看家lookHome()
要求:
1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:
花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
解题方案
操作步骤
- 定义猫类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，抓老鼠方法catchMouse()，方法中根据题目给出的格式输出成员变量的值。
- 定义狗类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，看家方法lookHome()，方法中根据题目给出的格式输出成员变量的值。
- 在测试类中使用有参构造创建猫类对象，调用eat()方法和catchMouse()方法。
- 在测试类中使用有参构造创建狗类对象，调用eat()方法和lookHome()方法。
参考答案
JavaSE 08 作业讲解和答案
知识点
面向对象
题目1（完成）
定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。
请定义出手机类，类中要有空参、有参构造方法，set/get方法。
定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。
调用对象的两个功能，打印效果如下：
正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
解题方案
操作步骤
- 定义手机类，手机类中定义String类型的品牌，int类型的价格，String类型的颜色，三个成员变量都用privice修饰。
- 提供空参构造方法和有参构造方法。
- 提供set/get方法。
- 编写打电话的成员方法，方法中对成员变量进行使用。
- 编写发短信的成员方法，方法中对成员变量进行使用。
- 在测试类中创建手机对象，使用set方法赋值，分别调用各个方法。
参考答案
public class Phone {
private String brand;
private double price;
private String color;
public Phone() {
}
public Phone(String brand, double price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void call() {
System.out.println("正在使用价格为" + price + "元" + color + "色的" + brand + "手机打电话....");
}
public void sendMessage() {
System.out.println("正在使用价格为" + price + "元" + color + "色的" + brand + "手机发短信....");
}
}
public class Test {
public static void main(String[] args) {
Phone p = new Phone();
p.setBrand("小米");
p.setColor("黑");
p.setPrice(3998);
p.call();
p.sendMessage();
}
}题目2（完成）
定义一个女朋友类。女朋友的属性包含：姓名，身高，体重。行为包含：洗衣服wash()，做饭cook()。另外定义一个用于展示三个属性值的show()方法。请在测试类中通过有参构造方法创建对象并赋值，然后分别调用展示方法、洗衣服方法和做饭方法。打印效果如下：
我女朋友叫凤姐,身高155.0厘米,体重130.0斤
女朋友帮我洗衣服
女朋友给我做饭训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
- 展示方法的作用就是打印姓名、身高、体重三个成员变量的值。
解题方案
操作步骤
- 定义女朋友类，定义String类型姓名，double类型身高和double类型体重三个成员变量，三个成员变量都用privice修饰。
- 提供空参构造方法和有参构造方法。
- 提供set/get方法。
- 编写展示方法show()，方法打印三个成员变量的值。
- 编写洗衣服wash()方法，输出洗衣服的语句。
- 编写做饭cook()方法，输出做饭的语句。
- 在测试类中使用有参构造创建女友对象，分别调用各个方法。
参考答案
public class GirlFriend {
private String name;
private double height;
private double weight;
public GirlFriend() {
}
public GirlFriend(String name, double height, double weight) {
this.name = name;
this.height = height;
this.weight = weight;
}
/**
* 获取
*
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
*
* @return height
*/
public double getHeight() {
return height;
}
/**
* 设置
*
* @param height
*/
public void setHeight(double height) {
this.height = height;
}
/**
* 获取
*
* @return weight
*/
public double getWeight() {
return weight;
}
/**
* 设置
*
* @param weight
*/
public void setWeight(double weight) {
this.weight = weight;
}
public void wash() {
System.out.println("女朋友帮我洗衣服");
}
public void cook() {
System.out.println("女朋友给我做饭");
}
public void show() {
System.out.println("我女朋友叫" + name + ",身高" + height + "厘米,体重" + weight + "斤");
}
}
public class Test {
public static void main(String[] args) {
GirlFriend gf = new GirlFriend("凤姐",155.0,130);
gf.show();
gf.wash();
gf.cook();
}
}题目3（完成）
定义项目经理类Manager。属性：姓名name，工号id，工资salary，奖金bonus。行为：工作work()
定义程序员类Coder。属性：姓名name，工号id，工资salary。行为：工作work()
要求：
1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:
工号为123基本工资为15000奖金为6000的项目经理张三正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员李四正在努力的写着代码......训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
- 在工作work()方法中调用成员变量，输出成员变量的值。
解题方案
操作步骤
- 定义项目经理类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id,salary,bonus的值。
- 定义程序猿类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id和salary的值。
- 在测试类中使用有参构造创建项目经理对象并赋值，调用工作方法打印结果。
- 在测试类中使用有参构造创建程序员对象并赋值，调用工作方法打印结果。
参考答案
public class Manager {
//姓名name，工号id，工资salary，奖金bonus。行为：工作work()
private String id;
private String name;
private double salary;
private double bonus;
public Manager() {
}
public Manager(String id, String name, double salary, double bonus) {
this.id = id;
this.name = name;
this.salary = salary;
this.bonus = bonus;
}
/**
* 获取
*
* @return id
*/
public String getId() {
return id;
}
/**
* 设置
*
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取
*
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
*
* @return salary
*/
public double getSalary() {
return salary;
}
/**
* 设置
*
* @param salary
*/
public void setSalary(double salary) {
this.salary = salary;
}
/**
* 获取
*
* @return bonus
*/
public double getBonus() {
return bonus;
}
/**
* 设置
*
* @param bonus
*/
public void setBonus(double bonus) {
this.bonus = bonus;
}
public void work() {
System.out.println("工号为" + id + "基本工资为" + salary + "奖金为" + bonus + "的项目经理"+name+"正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
}
}
public class Coder {
private String id;
private String name;
private double salary;
public Coder() {
}
public Coder(String id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
/**
* 获取
* @return id
*/
public String getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return salary
*/
public double getSalary() {
return salary;
}
/**
* 设置
* @param salary
*/
public void setSalary(double salary) {
this.salary = salary;
}
public void work() {
System.out.println("工号为" + id + "基本工资为" + salary + "的程序员"+name+"正在努力的写着代码......");
}
}
public class Test {
public static void main(String[] args) {
Manager m = new Manager("123","张三",15000,6000);
m.work();
Coder c = new Coder("135","李四",10000);
c.work();
}
}题目4（完成）
定义猫类Cat。属性:毛的颜色color，品种breed。行为:吃饭eat()，抓老鼠catchMouse()
定义狗类Dog。属性:毛的颜色color，品种breed。行为:吃饭()，看家lookHome()
要求:
1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:
花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....训练提示
- 类中的属性就是成员变量，类中的行为功能就是成员方法。
- 成员变量要被private修饰。
解题方案
操作步骤
- 定义猫类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，抓老鼠方法catchMouse()，方法中根据题目给出的格式输出成员变量的值。
- 定义狗类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，看家方法lookHome()，方法中根据题目给出的格式输出成员变量的值。
- 在测试类中使用有参构造创建猫类对象，调用eat()方法和catchMouse()方法。
- 在测试类中使用有参构造创建狗类对象，调用eat()方法和lookHome()方法。
参考答案
public class Cat {
private String color;
private String breed;
public Cat() {
}
public Cat(String color, String breed) {
this.color = color;
this.breed = breed;
}
/**
* 获取
*
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
*
* @param color
*/
public void setColor(String color) {
this.color = color;
}
/**
* 获取
*
* @return breed
*/
public String getBreed() {
return breed;
}
/**
* 设置
*
* @param breed
*/
public void setBreed(String breed) {
this.breed = breed;
}
public void eat() {
System.out.println(color + "色的" + breed + "正在吃鱼.....");
}
public void catchMouse() {
System.out.println(color + "色的" + breed + "正在逮老鼠....");
}
}
public class Dog {
private String color;
private String breed;
public Dog() {
}
public Dog(String color, String breed) {
this.color = color;
this.breed = breed;
}
/**
* 获取
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
* @param color
*/
public void setColor(String color) {
this.color = color;
}
/**
* 获取
* @return breed
*/
public String getBreed() {
return breed;
}
/**
* 设置
* @param breed
*/
public void setBreed(String breed) {
this.breed = breed;
}
public void eat() {
System.out.println(color + "色的" + breed + "正在啃骨头.....");
}
public void lookHome() {
System.out.println(color + "色的" + breed + "正在看家.....");
}
}
public class Test {
public static void main(String[] args) {
Cat c = new Cat("花","波斯猫");
c.eat();
c.catchMouse();
Dog d = new Dog("花","藏獒");
d.eat();
d.lookHome();
}
}JavaSE 09 作业讲解和答案
知识点
面向对象
题目1
题目描述：
定义数组存储3部汽车对象。
汽车的属性：品牌，价格，颜色。
创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组当中。
练习答案：
public class Car {
private String brand;//品牌
private int price;//价格
private String color;//颜色
public Car() {
}
public Car(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class CarTest {
public static void main(String[] args) {
//1.创建一个数组用来存3个汽车对象
Car[] arr = new Car[3];
//2.创建汽车对象，数据来自于键盘录入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
//创建汽车的对象
Car c = new Car();
//录入品牌
System.out.println("请输入汽车的品牌");
String brand = sc.next();
c.setBrand(brand);
//录入价格
System.out.println("请输入汽车的价格");
int price = sc.nextInt();
c.setPrice(price);
//录入颜色
System.out.println("请输入汽车的颜色");
String color = sc.next();
c.setColor(color);
//把汽车对象添加到数组当中
arr[i] = c;
}
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
Car car = arr[i];
System.out.println(car.getBrand() + ", " + car.getPrice() + ", " + car.getColor());
}
}
}题目2
题目描述：
定义数组存储3部手机对象。
手机的属性：品牌，价格，颜色。
要求，计算出三部手机的平均价格
练习答案：
public class Phone {
private String brand;//品牌
private int price;//价格
private String color;//颜色
public Phone() {
}
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class PhoneTest {
public static void main(String[] args) {
//1.创建一个数组
Phone[] arr = new Phone[3];
//2.创建手机的对象
Phone p1 = new Phone("小米",1999,"白色");
Phone p2 = new Phone("华为",4999,"蓝色");
Phone p3 = new Phone("魅族",3999,"红色");
//3.把手机对象添加到数组当中
arr[0] = p1;
arr[1] = p2;
arr[2] = p3;
//4.获取三部手机的平均价格
int sum = 0;
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素（手机对象）
Phone phone = arr[i];
sum = sum + phone.getPrice();
}
//5.求平均值
//数据能不写死，尽量不写死
//int avg = sum / arr.length;
double avg2 = sum * 1.0 / arr.length;
System.out.println(avg2);//3665.6666666666665
}
}题目3：
题目描述：
定义数组存储4个女朋友的对象
女朋友的属性：姓名、年龄、性别、爱好
要求1：计算出四女朋友的平均年龄
要求2：统计年龄比平均值低的女朋友有几个？并把她们的所有信息打印出来。
练习答案：
public class GirlFriend {
private String name;//姓名
private int age;//年龄
private String gender;//性别
private String hobby;//爱好
public GirlFriend() {
}
public GirlFriend(String name, int age, String gender, String hobby) {
this.name = name;
this.age = age;
this.gender = gender;
this.hobby = hobby;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
public class GirlFriendTest {
public static void main(String[] args) {
//1.定义数组存入女朋友的对象
GirlFriend[] arr = new GirlFriend[4];
//2.创建女朋友对象
GirlFriend gf1 = new GirlFriend("小诗诗",18,"萌妹子","吃零食");
GirlFriend gf2 = new GirlFriend("小丹丹",19,"萌妹子","玩游戏");
GirlFriend gf3 = new GirlFriend("小惠惠",20,"萌妹子","看书，学习");
GirlFriend gf4 = new GirlFriend("小莉莉",21,"憨妹子","睡觉");
//3.把对象添加到数组当中
arr[0] = gf1;
arr[1] = gf2;
arr[2] = gf3;
arr[3] = gf4;
//4.求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素（女朋友对象）
GirlFriend gf = arr[i];
//累加
sum = sum + gf.getAge();
}
//5.平均值
int avg = sum / arr.length;
//6.统计年龄比平均值低的有几个，打印他们的信息
int count = 0;
for (int i = 0; i < arr.length; i++) {
GirlFriend gf = arr[i];
if(gf.getAge() < avg){
count++;
System.out.println(gf.getName() + ", " + gf.getAge() + ", " + gf.getGender() + ", " + gf.getHobby());
}
}
System.out.println(count + "个");
}
}题目4：
题目描述：
定义数组存储3个学生对象。
学生的属性：学号，姓名，年龄。
要求1：添加的时候需要进行学号的唯一性判断。
要求2：添加完毕之后，遍历所有学生信息。
要求3：通过id删除学生信息
如果存在，则删除，如果不存在，则提示删除失败。
要求4：删除完毕之后，遍历所有学生信息。
要求5：id为2的学生，年龄+1岁
练习答案：
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
/*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
学生的属性：学号，姓名，年龄。
要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
要求2：添加完毕之后，遍历所有学生信息。
*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
//要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
Student stu4 = new Student(1, "zhaoliu", 26);
//唯一性判断
//已存在 --- 不用添加
//不存在 --- 就可以把学生对象添加进数组
boolean flag = contains(arr, stu4.getId());
if(flag){
//已存在 --- 不用添加
System.out.println("当前id重复，请修改id后再进行添加");
}else{
//不存在 --- 就可以把学生对象添加进数组
//把stu4添加到数组当中
//1.数组已经存满 --- 只能创建一个新的数组，新数组的长度 = 老数组 + 1
//2.数组没有存满 --- 直接添加
int count = getCount(arr);
if(count == arr.length){
//已经存满
//创建一个新的数组，长度 = 老数组的长度 + 1
//然后把老数组的元素，拷贝到新数组当中
Student[] newArr = creatNewArr(arr);
//把stu4添加进去
newArr[count] = stu4;
//要求2：添加完毕之后，遍历所有学生信息。
printArr(newArr);
}else{
//没有存满
//[stu1,stu2,null]
//getCount获取到的是2，表示数组当中已经有了2个元素
//还有一层意思：如果下一次要添加数据，就是添加到2索引的位置
arr[count] = stu4;
//要求2：添加完毕之后，遍历所有学生信息。
printArr(arr);
}
}
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
//创建一个新的数组，长度 = 老数组的长度 + 1
//然后把老数组的元素，拷贝到新数组当中
public static Student[] creatNewArr(Student[] arr){
Student[] newArr = new Student[arr.length + 1];
//循环遍历得到老数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//把老数组中的元素添加到新数组当中
newArr[i] = arr[i];
}
//把新数组返回
return newArr;
}
//定义一个方法判断数组中已经存了几个元素
public static int getCount(Student[] arr){
//定义一个计数器用来统计
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
count++;
}
}
//当循环结束之后，我就知道了数组中一共有几个元素
return count;
}
//1.我要干嘛？ 唯一性判断
//2.我干这件事情，需要什么才能完成？ 数组 id
//3.调用处是否需要继续使用方法的结果？ 必须返回
public static boolean contains(Student[] arr, int id) {
for (int i = 0; i < arr.length; i++) {
//依次获取到数组里面的每一个学生对象
Student stu = arr[i];
if(stu != null){
//获取数组中学生对象的id
int sid = stu.getId();
//比较
if(sid == id){
return true;
}
}
}
//当循环结束之后，还没有找到一样的，那么就表示数组中要查找的id是不存在的。
return false;
}
}
ublic class Test3 {
public static void main(String[] args) {
/*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
学生的属性：学号，姓名，年龄。
要求3：通过id删除学生信息
如果存在，则删除，如果不存在，则提示删除失败。
要求4：删除完毕之后，遍历所有学生信息。
*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
Student stu3 = new Student(3, "wangwu", 25);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
/*要求3：通过id删除学生信息
如果存在，则删除，如果不存在，则提示删除失败。*/
//要找到id在数组中对应的索引
int index = getIndex(arr, 2);
if (index >= 0){
//如果存在，则删除
arr[index] = null;
//遍历数组
printArr(arr);
}else{
//如果不存在，则提示删除失败
System.out.println("当前id不存在，删除失败");
}
}
//1.我要干嘛？ 找到id在数组中的索引
//2.我需要什么？ 数组 id
//3.调用处是否需要继续使用方法的结果？ 要
public static int getIndex(Student[] arr , int id){
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
Student stu = arr[i];
//对stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
//当循环结束之后，还没有找到就表示不存在
return -1;
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
}
public class Test4 {
public static void main(String[] args) {
/*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
学生的属性：学号，姓名，年龄。
要求5：查询数组id为“2”的学生，如果存在，则将他的年龄+1岁*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
Student stu3 = new Student(3, "wangwu", 25);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
//4.先要找到id为2的学生对于的索引
int index = getIndex(arr, 2);
//5.判断索引
if(index >= 0){
//存在， 则将他的年龄+1岁
Student stu = arr[index];
//把原来的年龄拿出来
int newAge = stu.getAge() + 1;
//把+1之后的年龄塞回去
stu.setAge(newAge);
//遍历数组
printArr(arr);
}else{
//不存在，则直接提示
System.out.println("当前id不存在，修改失败");
}
}
//1.我要干嘛？ 找到id在数组中的索引
//2.我需要什么？ 数组 id
//3.调用处是否需要继续使用方法的结果？ 要
public static int getIndex(Student[] arr , int id){
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
Student stu = arr[i];
//对stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
//当循环结束之后，还没有找到就表示不存在
return -1;
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
}JavaSE 10 作业讲解和答案
今日作业：
题目1
完成课堂上所有练习哦
题目2
键盘输入任意字符串，打乱里面的内容
训练目标
随机数类Random相关API、字符串相关API
训练提示
1、字符串是不可变的
2、如果要变化需要变成字符数组
3、调整完毕之后再变回字符串
参考答案
public class Test {
public static void main(String[] args) {
//键盘录入字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//把字符串变成字符数组
char[] arr = str.toCharArray();
//将数组里面的内容打乱
//打乱的核心要素：
//遍历数组得到每一个元素与每一个随机索引处的数据进行交换
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int index = r.nextInt(arr.length);
char temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
//将字符数组再变回字符串
String newStr = new String(arr);
//输出打印
System.out.println(newStr);
}
}题目3
训练目标：
生成验证码
内容：可以是小写字母，也可以是大写字母，还可以是数字
规则：
长度为5
内容中是四位字母，1位数字。
其中数字只有1位，但是可以出现在任意的位置。参考答案
public class Test {
public static void main(String[] args) {
//1.大写字母和小写字母都放到数组当中
char[] chs = new char[52];
for (int i = 0; i < chs.length; i++) {
//ASCII码表
if(i <= 25){
//添加小写字母
chs[i] = (char)(97 + i);
}else{//27
//添加大写字母
// A --- 65
chs[i] = (char)(65 + i - 26);
}
}
//定义一个字符串类型的变量，用来记录最终的结果
String code = "";
//2.随机抽取4次
//随机抽取数组中的索引
Random r = new Random();
for (int i = 0; i < 4; i++) {
int randomIndex = r.nextInt(chs.length);
//利用随机索引，获取对应的元素
//System.out.println(chs[randomIndex]);
code = code + chs[randomIndex];
}
//System.out.println(result);
//3.随机抽取一个数字0~9
int number = r.nextInt(10);
//生成最终的结果
code = code + number;
//4.变成字符数组打乱数据
char[] arr = code.toCharArray();
//将数组里面的内容打乱
for (int i = 0; i < arr.length; i++) {
int index = r.nextInt(arr.length);
char temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
//将字符数组再变回字符串
String result = new String(arr);
//输出打印
System.out.println(result);
}
}题目4
请编写程序，由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个。比如：Hello12345World中字母：10个，数字：5个。
训练目标
字符串遍历
训练提示
1、键盘录入一个字符串，用 Scanner 实现
2、要统计两种类型的字符个数，需定义两个统计变量，初始值都为0
3、遍历字符串，得到每一个字符
4、判断该字符属于哪种类型，然后对应类型的统计变量+1，判断字母时需要考虑大小写，条件比较复杂，怎样做才能使判断更简单呢？
训练步骤
1、创建键盘录入Scanner对象，使用nextLine方法接收输入的字符串。
2、为方便后续判断，使用String的toLowerCase方法，将字符串中的字符都转为小写。
3、需定义两个统计变量，初始值都为0
4、遍历字符串，得到每一个字符
5、判断该字符属于哪种类型，然后对应类型的统计变量+1，次数判断英文字母时只需判断小写即可。
参考答案
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// 为方便统计，将字符串中的字母都转为小写
line = line.toLowerCase();
//要统计两种类型的字符个数，需定义两个统计变量，初始值都为0
int letterCount = 0;
int numberCount = 0;
// 遍历字符串，得到每一个字符
for(int i=0; i<line.length(); i++) {
char ch = line.charAt(i);
// 判断该字符属于哪种类型，然后对应类型的统计变量+1
if (ch >= 'a' && ch <= 'z') {
letterCount++;
} else if (ch >= '0' && ch <= '9') {
numberCount++;
}
}
//输出两种类型的字符个数
System.out.println("英文字母：" + letterCount + "个");
System.out.println("数字：" + numberCount + "个");
}
}题目5
请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如：“abcba”、"上海自来水来自海上"均为对称字符串。
训练目标
字符串的反转功能，判断是否相等功能
训练提示
1、判断是否对称，方法的返回值是什么类型？参数列表是什么？
2、怎样判断对称呢？如果可以将字符串反转，反转后发现跟原来的字符串完全一样，不就可以判断出来了吗，那么哪个类有字符串的反转功能呢？
训练步骤
1、定义方法，返回值类型为boolean，参数列表为String类型的一个参数。
2、将字符串转换为StringBuilder类型，调用StringBuilder的reverse()方法将字符串反转。
3、将反转后的字符串再转回String类型，并与原字符串比较，如果相等，返回true，否则返回false
4、在主方法中，定义一个字符串，调用方法测试结果。
参考答案
public class Test {
public static void main(String[] args) {
String str = "上海自来水来自海上";
System.out.println(isSym(str));
}
public static boolean isSym(String str) {
// 为了程序的健壮，如果传递的是空值，返回false
if (str == null) {
return false;
}
// 转换为StringBuilder
StringBuilder sb = new StringBuilder(str);
// 反转，再转成String
String reStr = sb.reverse().toString();
// 比较与原字符串是否相等
// 相等返回true，不相等返回false，正好与equals的返回值一致，直接返回即可。
return reStr.equals(str);
}
}题目6
我国的居民身份证号码，由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法，并在主方法中调用方法测试结果。规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
训练目标
字符串的遍历、判断
训练提示
1、要判断字符串是否符合规则，方法的返回值类型是什么？参数列表是什么？
2、使用String的API，对每种不符合条件的情况作出判断，一旦发现不符合条件就可以结束方法的执行，返回结果了。
3、在主方法中创建键盘录入，调用方法，输入各种数据测试结果。
训练步骤
1、定义方法，返回值类型为boolean表示是否合法，参数列表为String类型的id，表示要判断的数据。
2、对每种不符合条件的情况作出判断
2.1、如果字符串长度不是18，返回false。
2.2、如果字符串以数字"0"开头，返回false。
2.3、遍历字符串，获取每一位字符，判断前17位，如果不是数字，返回false，判断最后一位如果不是数字或者X，返回false
2.4、所以的不符合条件都筛选完成，返回true
3、在主方法中创建键盘录入Scanner对象，调用nextLine()方法，获取用户输入，调用方法，传递参数，查看结果。要多运行几次，判断各种不符合条件的数据。
参考答案
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入身份证号：");
String id = sc.nextLine();
System.out.println(check(id));
}
// 返回值boolean类型，表示是否符合规则。参数列表：需要判断的字符串
public static boolean check(String id) {
// 如果传递了空参数，返回false
if (id == null) {
return false;
}
// 如果是数字0开头，返回false
if (id.startsWith("0")) {
return false;
}
// 如果不是18位，返回false
if (id.length() != 18) {
return false;
}
// 遍历判断每一位
for (int i = 0; i < id.length(); i++) {
char ch = id.charAt(i);
// 前17位都是数字,最后一位可以是数字或者大写字母X
if (i == id.length() - 1) { // 最后一位
if (ch < '0' || ch > '9' && ch != 'X') { // 不是数字或者X
return false;
}
} else { // 其他位
if (ch < '0' || ch > '9') { // 不是数字
return false;
}
}
}
// 所有的规则都符合，返回true
return true;
}
}题目7
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
要求：
1、如果传递的参数为空，返回null
2、如果传递的数组元素个数为0，返回[]
3、如果数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
训练目标
字符串的拼接
训练提示
1、定义方法的返回值是什么？参数列表是什么？
2、如果不做判断就对数组进行遍历，那么如果数组对象为空，会报出异常，怎样避免空指针异常呢？
3、拼接字符串必然涉及到频繁改变，该采用可变的字符序列StringBuilder比较好
4、遍历数组，按照题目格式拼接数组中的元素。
5、将字符串返回
6、在主方法中定义数组，并调用方法，打印结果
训练步骤
1、定义方法返回值类型：String，参数：int[] arr
2、判断对象如果为null，直接返回null
3、创建StringBuilder对象
4、遍历数组，按照要求进行拼接数组元素，如果是不是最后一个元素，还要拼接逗号和空格
5、将StringBuilder转为String返回
6、在主方法中定义数组，并调用方法，打印结果
参考答案1
public class Test {
public static void main(String[] args) {
// 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
// 调用方法，输出结果
System.out.println(arrayToString(arr));
}
/*定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
返回值类型：String
参数：int[] arr
*/
public static String arrayToString(int[] arr) {
// 健壮性判断
if (arr == null) {
return null;
}
//在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
// 拼接元素
sb.append(arr[i]);
// 如果不是最后一个元素，再拼接逗号和空格
if (i != arr.length - 1) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
}参考答案2：
public class Test {
public static void main(String[] args) {
// 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
// 调用方法，输出结果
System.out.println(arrayToString(arr));
}
public static String arrayToString(int[] arr) {
// 健壮性判断
if (arr == null) {
return null;
}
//在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
StringJoiner sj = new StringJoiner(", ","[","]");
for (int i = 0; i < arr.length; i++) {
sj.add(arr[i] + "");
}
return sj.toString();
}
}题目8（扩展）
在String类的API中，有如下两个方法：
// 查找参数字符串str在调用方法的字符串中第一次出现的索引，如果不存在，返回-1
public int indexOf(String str)
// 截取字符串，从索引beginIndex（包含）开始到字符串的结尾
public String substring(int beginIndex)请仔细阅读API中这两个方法的解释，完成如下需求。
现有如下文本：“Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的”。请编写程序，统计该文本中"Java"一词出现的次数。
训练目标
String类API的灵活使用
训练提示
1、要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
2、如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，而剩余字符串的起始位是出现位置再加上子串的长度。
3、以此类推，通过循环完成查找，如果找不到就是-1，每次找到用计数器记录次数。
训练步骤
1、定义方法，返回值int表示次数，参数列表两个字符串，第一个表示在哪个字符串中查找，第二个表示要查找的目标子串
2、定义统计变量表示次数。
3、定义索引变量，表示每次找到子串出现的索引。
4、定义循环，判断条件为在字符串中找到了目标子串，使用indexOf实现。
5、如果找到的索引不是-1，在循环中，统计变量累加。
6、把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取，使用substring实现。
7、将统计变量返回
8、在主方法中，定义字符串表示题目中的文本，定义字符串表示要查找的子串，调用方法，获取结果。
参考答案1
public class Test {
public static void main(String[] args) {
String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
String tar = "Java";
// 调用方法并输出
System.out.println(search(str, tar));
}
// 返回值int表示次数，参数列表str表示在哪个字符串中查找，tar表示要查找的目标子串
public static int search(String str, String tar) {
// 定义统计变量表示次数
int count = 0;
// 定义索引变量，表示每次找到子串出现的索引
int index = -1;
// 定义循环，判断条件为在字符串中找到了目标子串
while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
// 次数累加
count++;
// 把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取。
str = str.substring(index + tar.length());
}
return count;
}
}参考答案2
public class Test {
public static void main(String[] args) {
String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
String tar = "Java";
// 调用方法并输出
System.out.println(search(str, tar));
}
// 替换之后求长度差
public static int search(String str, String tar) {
String newStr = str.replace(tar, "");
int count = (str.length() - newStr.length()) / tar.length();
return count;
}
}JavaSE 11 作业讲解和答案
JavaSE 12 作业讲解和答案
JavaSE 13 作业讲解和答案
JavaSE 14 作业讲解和答案
JavaSE 15 作业讲解和答案
JavaSE 16 作业讲解和答案
JavaSE 17 作业讲解和答案
JavaSE 18 作业讲解和答案
JavaSE 19 作业讲解和答案
