达内Core Java练习题解答
5星
- 浏览量: 0
- 大小:None
- 文件类型：RAR
简介：
首先，需要开发一个程序，用于对输入的年份进行判定，以确定其是否为闰年。闰年的判断标准如下：
（1）如果该年份可以被4整除，但不能被100整除，那么它就属于闰年。
（2）此外，如果该年份能够被400整除，则它同样会被认定为闰年。
import java.util.Scanner;
class Bissextile {
public static void main(String[] arge) {
System.out.print(请输入年份：);
int year; // 定义输入的年份名字为“year”
Scanner scanner = new Scanner(System.in);
year = scanner.nextInt();
if (year < 0 || year > 3000) {
System.out.println(年份有误，程序将退出！);
System.exit(0);
}
if ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) {
System.out.println(year + 是闰年);
} else {
System.out.println(year + 不是闰年);
}
}
}
2. 对于提供的百分制分数，系统将根据分数范围将其归类到相应的等级。具体而言，分数达到90分或更高将被评定为A级，80至89分之间则为B级，70至79分之间为C级，60至69分之间为D级，而低于60分的成绩将被判定为E级。
import java.util.Scanner;
class Mark {
public static void main(String[] args) {
System.out.println(请输入一个分数);
// 定义输入的分数为“mark”，且分数会有小数
double mark;
Scanner scanner = new Scanner(System.in);
mark = scanner.nextDouble();
// 进一步说明，这里读取的是用户输入的浮点数，用于存储学生的成绩。
}
}
检查是否存在输入错误。
如果标记值小于零或大于100，则输出“输入有误！”并程序退出。
*用于确定分数等级的判断*
对于90分及以上，评定为A级；对于80到89分，评定为B级；对于70到79分，评定为C级；对于60到69分，评定为D级；对于60分以下，评定为E级。
如果标记值大于等于90，则输出“该分数等级为A”。 否则，如果标记值大于等于80，则输出“该分数等级为B”。 接着，如果标记值大于等于70，则输出“该分数等级为C”。 如果标记值大于等于60，则输出“该分数等级为D”。 最后，如果标记值小于60，则输出“该分数等级为E”。
3，请编写程序计算 1 + 3 + 5 + 7 + ... + 99 这些整数的和。
class he{
public static void main(String[] args){
int number = 1; // 设置初始值为1，后续每次递增2。
int sum = 0;
for ( ; number <100; number+=2 ){ sum += number; }
System.out.println(1+3+5+7+……+99 = +sum);
}
}
4、运用for循环来输出 9x9 的乘法表？
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
通过嵌套循环，程序能够生成并展示九九乘法表。
在 `main` 方法中，使用嵌套 `for` 循环来实现这一功能。外部循环控制行数，内部循环控制列数。
老师的实现方式中，在判断语句中使用了 `k <= j` 来避免不必要的计算。 此外，为了优化效率，可以考虑使用 `continue` 代替 `break`，尽管这种方式可能会略微降低性能。
程序通过 `System.out.print()` 输出乘法表达式，并通过 `System.out.println()` 在每一行末尾换行，从而完整地呈现九九乘法表。
6、程序需生成所有满足条件的“水仙花数”。具体而言，“水仙花数”指的是一个三位数的整数，其每位数字的立方和恰好等于该数本身。例如，153 是一个“水仙花数”，因为 1 的立方 + 5 的立方 + 3 的立方 = 1 + 125 + 27 = 153。
class DafodilNumber {
public static void main(String[] args) {
System.out.println(以下是所有的水仙花数);
int number = 100; 鉴于水仙花数定义为由三位数字组成的数字，且从100开始计算，因此从100开始计数。
}
}
int i, j, k; 这些变量分别代表数字的百位、十位和个位数值。
for (int sum; number < 1000; number++) {
i = number / 100;
j = (number - i * 100) % 10;
k = number - i * 100 - j * 10;
sum = i * i * i + j * j * j + k * k * k;
if (sum == number) System.out.println(number + 是一个达芬奇数！);
}
}
7、计算表达式 a + aa + aaa + ... + aaaaaaaaa = ?，其中 a 是 1 到 9 之间的任意一个数字，并且可以指定项数。
import java.util.Scanner;
class Multinomial {
public static void main(String[] args) {
int a; // 声明用于接收用户输入的整数 a
int howMany; // 声明用于接收用户输入的项数
Scanner scanner = new Scanner(System.in);
System.out.println(请输入一个 1 到 9 的 a 值：);
a = scanner.nextInt();
System.out.println(请问要相加多少项？);
howMany = scanner.nextInt();
int sum = 0; // 初始化和为 0
int a1 = a; // 保存 a 的初始值，用于后续计算
for (int i = 1; i <= howMany; i++) {
sum += a; // 将当前 a 加到总和中
a = 10 * a + a1; // 计算下一项的值，即前一项乘以 10 再加上初始值 a。注意，a 的值已经更新。
}
System.out.println(和为： + sum); // 输出计算得到的总和
}
}
求前20项 21+32+53+85+138......之和。
class Sum {
public static void main(String[] args) {
double sum = 0;
double numerator = 2.0, denominator = 1.0; // 初始化分子 (numerator) 为 2，分母 (denominator) 为 1
for (int i = 1; i <= 20; i++) {
sum += numerator * denominator; // 将分子乘以分母，累加到总和中
denominator = numerator; // 计算下一次的分母，使其等于当前的分子
numerator += denominator; // 计算下一次的分子，使其等于当前分子加上分母
}
System.out.println(The sum is: + sum); // 输出计算得到的总和值。
}
}
通过运用编程技术，生成以下图形：
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
class Asterisk {
public static void main(String[] args) {
for (int i = 1; i <= 13; i += 2) {
for (int j = 1; j <= i && i + j <= 14; j++) {
System.out.print(*);
}
System.out.println(); // 添加注释以说明换行操作
}
}
}
11、计算圆周率。该公式为：PI = 4 - 4/3 + 4/5 - 4/7 + ... 等级求和。程序需输出第一个数值，其结果大于 3.1415 但小于 3.1416。
class Pi {
public static void main(String[] args){
double pi = 0; // 设定初始值，用于存储计算结果。
double fenZi = 4; // 定义分子，初始值为4，用于计算每一项的近似值。
double fenMu = 1; // 定义分母，初始值为1，随着循环进行，分母会递增2。
for (int i = 0; i < 1000000000; i++){ // 循环迭代10亿次，以提高精度。虽然迭代次数较多，但可以显著提升计算准确度。
pi += (fenZifenMu) ; // 将当前分子和分母相乘的结果累加到 pi 中。
fenZi *= -1.0; // 更新分子：将分子乘以-1.0,实现正负交替变化。
fenMu += 2.0; // 更新分母：将分母增加2.0,实现分母递增2的规律。
}
System.out.println(pi); // 输出计算得到的 pi 值。
}
}
该程序通过一个循环计算圆周率 π 的近似值。程序首先定义了变量 `pi` 用于存储结果, `fenZi` 代表分子, `fenMu` 代表分母。循环内部不断更新分子和分母的值，并将其相乘后累加到 `pi` 中。分子每次变化为 +4 和 -4 交替出现，而分母每次递增2。循环迭代了十亿次以获得较高的精度，最终输出计算得到的 π 值约为3.1415926525880504，但由于迭代次数有限，结果可能存在一定的误差。
12、请提供一个数据值n，并以此计算斐波那契数列（Fibonacci）中第n项的值。数列的初始值为：1 1 2 3 5 8 13 21 34。
该数列遵循以下规律：每个数值等于其前两个数值的总和。
接下来，我们将展示一个用于计算斐波那契数列（Fibonacci）第n项值的Java程序：
```java
public class Fibonacci {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]); // 从命令行获取输入数据n
int n1 = 1; // 定义第一个斐波那契数
int n2 = 1; // 定义第二个斐波那契数
int sum = 0; // 定义累加和
if (n <= 0) {
System.out.println(参数错误!); // 如果n小于等于0，则输出错误信息
return;
}
if (n <= 2) {
sum = 1; // 如果n小于等于2，则第n项的值为1
} else {
for (int i = 3; i <= n; i++) {
sum = n1 + n2; // 计算当前数值为前两个数值之和
n1 = n2; // 更新第一个斐波那契数
n2 = sum; // 更新第二个斐波那契数
}
}
System.out.println(sum); // 输出计算得到的第n项斐波那契数。
}
}
```
该程序旨在计算斐波那契数列（Fibonacci）中特定项的值，并将其余项全部输出。
以下是一个名为`FibonacciPrint`的Java类，其`main`方法实现了这一功能：
```java
public class FibonacciPrint {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]); // 从命令行获取要计算的斐波那契数列的项数
FibonacciPrint t = new FibonacciPrint(); // 创建FibonacciPrint类的实例
for (int i = 1; i <= n; i++) { // 循环迭代计算并打印数列中的每个值
t.print(i); // 调用print方法打印当前项的值
}
}
public void print(int n) { // 定义一个名为print的方法，用于计算和打印单个斐波那契数的值
int n1 = 1; // 初始化第一个斐波那契数
int n2 = 1; // 初始化第二个斐波那契数
int sum = 0; // 初始化和变量
if (n <= 0) { // 检查输入参数是否有效
System.out.println(参数错误!); // 如果参数无效，则输出错误信息并返回
return;
}
if (n <= 2) { // 如果要计算的项数为2或更小，则直接返回1，因为前两个斐波那契数都是1。
sum = 1;
} else { // 如果要计算的项数大于2，则进行循环计算。
for (int i = 3; i <= n; i++) { // 从第三个数字开始迭代到n为止。 每次将前两个数字的和赋值给sum, 然后将第二个数赋值给n1, 将sum赋值给n2。 这样就完成了对下一个斐波那契数的计算。 注意这里i从3开始是因为我们已经定义了前两个数字n1和n2。
sum = n1 + n2; // 计算当前斐波那契数的值并将结果存储在sum变量中。
n1 = n2; // 将第二个数更新为当前斐波那契数的前一个值。
n2 = sum; // 将当前斐波那契数的计算结果更新为第二个数的值。
}
}
System.out.println(sum); // 输出计算出的斐波那契数列中的第n个值 。
}
}
```
13、计算数列 1 - 13 + 15 - 17 + 19 ... 的前50项之和。
a、确定并计算该数列的前50项的和。
b、求出数列中最后一项的绝对值小于 1e-5 的和。
15、将金字塔图案打印到屏幕上，共呈现n行，例如当n等于5时，图案将显示如下：
*
* *
* *
* *
* *
该程序用于生成金字塔形状的星号图案。
以下代码定义了一个名为 `PrintStar` 的类，其中包含 `main` 方法。
在 `main` 方法中，程序首先接收一个整数参数 `col`，该参数表示金字塔的列数。
然后，使用一个 `for` 循环迭代每一行（从 1 到 `col`）。
在每一行的循环中，程序首先打印若干个空格，以实现金字塔的对齐效果。 这部分通过另一个 `for` 循环完成，其迭代次数由 `col - i` 决定，从而控制打印空格的数量。
接下来，程序打印星号。 利用第三个 `for` 循环，它迭代 `2*i - 1` 次，从而在当前行打印相应数量的星号。
最后，使用 `System.out.println()` 语句换行，以便开始下一行的打印操作。
16、歌德巴赫猜想指出，每一个大于六的偶数都可以被分解成两个质数之和。程序将枚举并输出所有满足此条件的可能组合。
任何一个大于六的偶数，都可以被分解成两个质数的总和。程序将输出所有满足此条件的可能组合。
以下是一个Java程序，用于实现此功能：
```java
public class Gedebahe{
public static void main(String args[]){
int num = Integer.parseInt(args[0]);
if(num<=6){
System.out.println(参数错误!);
return;
}
if(num%2!=0){
System.out.println(参数错误!);
return;
}
Gedebahe g = new Gedebahe();
// 1不是质数, 2是偶数, 因此从3开始循环
for(int i=3; i<=num; i++){
if(i%2==0){ //如果为偶数，则跳过本次循环迭代。
continue;
}
// 当i和num-i都为质数时，满足条件，打印结果。
if(g.isPrime(i) && g.isPrime(num-i)){
System.out.println(i + + + (num-i) + = + num);
}
}
}
// 辅助函数：判断一个数是否为质数。 （这里省略了isPrime的具体实现）
private boolean isPrime(int n) {
// 实现质数判断逻辑... 例如：遍历到sqrt(n)即可。 此处省略具体实现以保持代码简洁性。
return false; // Placeholder - Replace with actual prime check logic
}
}
```
第4章 数组
首先，需要创建一个包含十个元素的整数一维数组，并为每个元素赋予随机生成的整数值。随后，程序应计算并确定该数组中所有元素的最高值、最低值、平均值以及总和。最后，将这些计算结果以清晰的方式输出到控制台或指定输出区域。
class ArrayNumber {
public static void main(String[] args) {
int[] arrayNumber;
arrayNumber = new int[10];
System.out.println(以下是随机生成的10个整数：);
// 填入随机的 10个整数 (This line is intentionally left blank as its a placeholder for the random number generation)
for (int i = 0; i < arrayNumber.length; i++) {
arrayNumber[i] = (int) (100 * Math.random());
System.out.print(arrayNumber[i] + );
}
System.out.println();
int max = arrayNumber[0];
int min = arrayNumber[0];
int sum = 0;
for (int i = 0; i < arrayNumber.length; i++) {
if (max < arrayNumber[i]) {
max = arrayNumber[i]; // 更新最大值。
}
if (min > arrayNumber[i]) {
min = arrayNumber[i]; // 更新最小值。
}
sum += arrayNumber[i]; // 计算总和。
}
System.out.println(最大值： + max + , 最小值： + min + , 总和： + sum + , 平均值： + (double) sum / arrayNumber.length); // 输出结果。
}
}
第二步，声明一个整型的一维数组，其大小为10个元素，并依次赋予它们从1到10的整数值。随后，对数组中的每个元素进行循环操作，将每个元素的值向左移动一位位置。具体而言，数组的第一个元素的值将被赋值为第二个元素的值，第二个元素的值将被赋值为第三个元素的值，以此类推，直到最后一个元素的原始值被赋予第一个元素。最后，请将修改后的数组内容输出到屏幕上以供观察。
3. 首先，需要建立一个整数类型的单维数组，其大小为40个元素，用于记录每个学员的考试分数。随后，通过随机数生成器产生40个介于0到100之间的随机整数，并将这些随机数依次存入该数组中。接着，计算所有成绩的平均值，最后统计那些分数低于平均分学员的数量，并将这个数量输出到屏幕上。
4. （可选）在此基础上，请将前述的40条成绩数据按照由高到低的顺序进行排列展示。
通过编程实现，可以将一个数组中的元素顺序颠倒。 举例来说，如果初始数组包含数值 1、2、3、4 和 5，那么经过倒排操作后，数组中的值将变为 5、4、3、2 和 1。
要求首先创建一个包含100个元素的整型数组a，并用100个随机生成的四位整数填充该数组。随后，定义一个包含10个元素的整型数组b。接着，计算数组a中的每个元素除以10的余数，并统计余数为0的元素的个数，将该结果存储在b[0]中；统计余数为1的元素的个数，并将结果存储在b[1]中，以此类推，直至统计出余数为9的元素的个数并将其结果存储在b[9]中。
class Remain {
public static void main( String[] args) {
int[] a = new int[100];
// 初始化数组，为后续操作做准备。
for (int i = 0; i < 100; i++) {
a[i] = 0; // 或者其他合适的初始值，例如随机数等。
}
// 接下来可以对数组进行各种操作，例如赋值、遍历、排序等。
// 这里只展示了数组的声明和初始化。
}
}
将随机生成的四位整数，共计一百个，存储到数组 `a` 中。 循环迭代执行以下操作：从 `i = 0` 到 `a.length - 1`，每次迭代将 `a[i]` 的值设置为一个介于 0 到 9999.999...之间的随机数，并将其转换为整数类型后赋值给 `a[i]`。
这段代码用于计算数组 `a` 中每个元素除以 10 的余数，并统计这些余数出现的次数。首先，声明了一个包含 10 个元素的整数数组 `b`，以及两个整型变量 `k` 和 `sum`。然后，使用嵌套循环遍历数组 `b` 中的每个索引 `j`。在内层循环中，遍历数组 `a` 中的每一个元素 `a[k]`。如果 `a[k]` 除以 10 的余数等于当前循环变量 `j`，则将计数器 `sum` 加 1。在内层循环结束后，将 `sum` 的值赋给数组 `b` 的第 `j` 个元素。最后，使用 `System.out.printf()` 方法将数组 `b` 中第 `j` 个元素的值输出到控制台，格式为 b[j]=value。
7. 首先，创建一个20行5列的二维数组，用于记录某班级共20名学员在五门课程上的成绩。这五门课程的顺序分别是：核心C++、核心Java、Servlet、JSP和EJB。
（1）随后，通过循环迭代访问二维数组中的每一个元素，并为其分配一个介于0到100之间的随机整数。
（2）接着，以列表的形式展示每个学员在每门课程中所取得的成绩。
（3）在此基础上，需要编写程序来计算每个学员的总分，并将这些总分存储在一个独立的单维数组中。
（4）最后，需要编写程序计算所有学员在特定某门课程上的平均分。
该代码片段定义了一个名为 `Student` 的类，其中包含一个 `main` 方法。该方法声明了一个二维整数数组 `mark`，其大小为 20 行 5 列。程序随后会为学生分配分数，这些分数是随机生成的。循环的初始化部分存在错误，需要修正以完成程序的逻辑。
8. 编写一个九宫格程序，其布局呈现出井字形（必须为奇数行列数），并填充数字。这些数字应被精心安排，以确保每一行、每一列以及两条对角线的数值之和均相等。
经验规则规定，起始于 1 的数字应按照顺序依次递增，并且第一行的中间位置应放置该数字。随后，下一个数字应向右上角斜向填充，以 45 度角进行递增。若数值超出单边边界，则应采用头尾相接的方式进行填充。同时，如果存在数值填写的冲突情况，则将该数值填入之前位置的底下一格。此外，若数字同时超出两侧边界，则同样将该数值填入之前位置的底下一格。
我认为，首先应该将中间的数字放置在九宫格的中心位置；随后，按照既定规则依次填充剩余的数字，同时确保头部和尾部对应的数字分别填入其相应的格子。(第 n 个数值与倒数第 n 个数值之间存在对应关系，且九宫格以中心格为对称轴。)
通过这种方法，能够同时完成两个数字的填写，从而显著提升了操作效率。虽然其准确性仍需通过严谨的数学证明来证实（但经过多次实验并未发现任何错误。）
此外，九宫格的 1 单元格可以被安置在其他三个位置上；然而，后续的填充顺序则需要相应调整。进一步地，根据九宫格本身的对称性特征，至少存在八种不同的填写方案。
import java.util.Scanner;
class NinePalace {
public static void main(String[] args) {
定义 N 为九宫格的行列数，需要输入。
System.out.println(请输入九宫格的行列规模（只能是奇数的）);
Scanner n = new Scanner(System.in);
int N;
确定一个格局是否为奇数，能够识别出偶数、负数以及小数。
声明一个双精度浮点型变量 `d`。
进入一个无限循环 `while (true)`：
首先，将用户输入的数值赋值给变量 `d`，使用 `n.nextDouble()` 方法获取。随后，将 `d` 转换为整数类型并存储在变量 `N` 中。
接着，检查以下条件之一是否成立：如果 `d` 与 `N` 的差值大于 1.0E-4（即小于 1.0E-4），或者 `N` 是偶数，或者 `N` 是负数，则输出错误信息“输入出错，格局只能是正奇数。请重新输入。”。
如果以上任何条件都不成立，则执行 `break` 语句，跳出循环。
为了记录老师的九宫格填写结果，首先需要创建一个二维整数数组，用于存储九宫格中的每个数字。具体而言，声明一个名为 `result` 的二维数组，其大小为 `N` 行 `N` 列，用于保存九宫格的填充值。随后，初始化行索引 `row` 为 0，列索引 `col` 为 `N/2` (因为列从 0 开始计数)，代表九宫格的起始位置。
接着，使用一个循环从 1 迭代到 `N*N`，每次迭代将当前循环计数器 `i` 赋值给数组 `result` 的当前单元格：`result[row][col] = i;`。在循环内部，通过递减行索引 `row--` 和递增列索引 `col++` 来逐步向九宫格的中心移动。
如果行索引 `row` 变为负数且列索引 `col` 大于或等于 `N`，则表示已经到达了九宫格的边界之外。此时，需要调整列索引为 `col--` 并增加行索引为 2 (`row += 2;`) 以确保填充值继续在九宫格内移动。
如果行索引 `row` 变为负数，则意味着行已经越界了。在这种情况下，将行索引重置为九宫格的倒数第二行位置 (`N-1`)。
如果列索引 `col` 大于或等于 `N`，则表示列已经越界了。在这种情况下，将列索引重置为 0。
如果数组 `result[row][col]` 中已经存在了非零值（即存在冲突），则需要调整列索引为 `col--`, 并增加行索引为2 (`row += 2;`) ，以避免冲突并继续填充九宫格。
通过循环嵌套的结构，程序会生成一个九宫格的打印输出。外层循环从 i=0 迭代到 i
此外，该类还提供了一个公共方法 `getName()`，用于返回员工的姓名。同时，它包含一个构造函数 `Employee(String name, int birth)`，该构造函数接受员工姓名和出生年份作为参数，并将其分别赋值给类的成员变量 `name` 和 `birth`。
还有一个名为 `getSalary(int month)` 的方法，它根据员工的出生月份来计算工资。如果传入的月份与员工的出生月份相同，则返回 100；否则，返回 0。
The `SalariedEmployee` class inherits from the `Employee` class. It defines a salaried employee object with a specific salary structure. This class includes a private instance variable named `salary` of type `double`, which represents the employees fixed compensation. The `SalariedEmployee` class is initialized with a name (String), birthdate (int), and a base salary (double) through its constructor. During construction, the `super(name, birth)` call invokes the constructor of the parent `Employee` class to set the employees name and birthdate. Subsequently, the `this.salary = salary;` statement assigns the provided base salary to the instance variable `salary`. The class provides a method called `getSalary(int month)` that calculates and returns the total monthly salary for a given month. This method combines the employees base salary (obtained using `super.getSalary(month)`) with their fixed monthly salary (`salary`). 该类 HourlyEmployee 继承自 Employee 类。它包含以下私有成员变量： hourlySalary（小时工资）和 hour（工作小时数）。构造函数 HourlyEmployee(String name, int birth, double hourSalary, int hour) 接受员工姓名、出生日期、小时工资和工作小时数作为参数，并调用父类 Employee 的构造函数进行初始化。此外，它将 hourlySalary 设为 hourlySalary，将 hour 设为 hour。getSalary(int month) 方法计算员工的月薪。如果工作小时数小于等于 160 小时，则返回 hourlySalary 乘以 hour 的值加上父类 Employee 的月薪；否则，返回 160 倍 hourlySalary 的值加上剩余小时数（hour - 160 小时）的 hourlySalary 的 1.5 倍，再加上父类 Employee 的月薪。 该SalesEmployee类继承自Employee类。它包含两个私有成员变量：销售额sales和绩效pre。构造函数SalesEmployee接受员工姓名name、出生日期birth、销售额sales和绩效pre四个参数，并调用父类Employee的构造函数进行初始化。同时，将销售额this.sales和绩效this.pre分别赋值给对应的成员变量。getSalary方法根据月份month计算员工的工资，返回销售额sales乘以绩效pre再加上父类Employee的getSalary方法计算的工资之和。 class BaseSalarySalesEmployee extends SalesEmployee { private double baseSalary; public BaseSalarySalesEmployee(String name, int birth, double sales, double pre, double baseSalary) { super(name, birth, sales, pre); this.baseSalary = baseSalary; } public double getSalary(int month) { return this.baseSalary + super.getSalary(month); } } * 对现有的员工练习程序进行代码修订。 * 公司将为SalaryEmployee每月额外支付2000元的加班费，为BasePlusSalesEmployee支付1000元的加班费。 * 修改现有的代码，以包含上述的加班费发放逻辑。 * 编写一个方法，用于打印出本月公司总共发放的加班费金额。 * @author Administrator public class EmployeeTest { * @param args * public static void main(String[] args) { Employee e[] = new Employee[4]; e[0] = new SalariedEmployee(魏威, 10, 5000); e[1] = new HourlyEmployee(段利峰, 8, 80, 242); e[2] = new SalesEmployee(林龙, 11, 300000, 0.1); e[3] = new BasedPlusSalesEmployee(华溪, 1, 100000, 0.15, 1500); for (int i = 0; i < e.length; i++) { System.out.println(e[i].getName() + : + e[i].getSalary(11)); } 通过对员工列表 `e` 进行遍历，计算加班费总额。程序首先初始化一个变量 `result` 为 0。然后，对于列表中的每一个元素 `e[i]`，进行以下判断：如果该元素是 `SalariedEmployee` 类型，则将其转换为 `SalariedEmployee` 对象 `s`，并累加其加班费 `s.getAddtionalSalary()` 到 `result` 中。如果该元素是 `BasedPlusSalesEmployee` 类型，则将其转换为 `BasedPlusSalesEmployee` 对象 `b`，并同样累加其加班费 `b.getAddtionalSalary()` 到 `result` 中。最终，计算出的加班费总额存储在变量 `result` 中。 for (int i = 0; i < e.length; i++) { result += e[i].getAddtionalSalary(); } System.out.println(加班费: + result); } 该接口定义了一个名为 AddtionalSalary 的模块，其核心功能在于提供获取额外工资的方法。具体来说，它包含一个名为 getAddtionalSalary 的函数，该函数负责计算并返回员工的额外工资数值。该类 `Employee` 实现了 `AddtionalSalary` 接口。它包含员工姓名和生日月份作为其私有属性。
构造函数 `Employee` 接受员工姓名和生日月份作为参数，并将其分别赋值给 `name` 和 `birth` 属性。
`getSalary` 方法计算员工的工资。如果当月与员工的生日月份相同，则返回 100；否则，返回 0。
`getName` 方法用于获取员工的姓名。
This function returns an integer value representing any additional salary.该类 `SalariedEmployee` 继承自 `Employee` 类。
它包含一个私有变量 `salaryPerMonth`，用于存储每月固定工资。
构造函数 `SalariedEmployee(String name, int birth, int salaryPerMonth)` 接受员工姓名、出生日期和每月固定工资作为参数，并调用父类的构造函数进行初始化，同时将 `salaryPerMonth` 赋值给实例变量。
方法 `getSalary(int month)` 返回员工在指定月份的工资，该工资包括每月固定工资、月份基本工资以及额外的补贴工资。
方法 `getAddtionalSalary()` 返回额外的补贴工资，其值为 2000。
该`HourlyEmployee`类继承自`Employee`类。它包含以下私有成员变量：`salaryPerHour`（每小时工资）和`hoursPerMonth`（每月工作小时数）。构造函数接受员工姓名、出生日期、每小时工资和每月工作小时数作为参数，并调用父类的构造函数进行初始化。此外，它还定义了一个名为`getSalary`的方法，该方法计算员工在给定月份的薪水。如果每月工作小时数小于等于160小时，则薪水等于每月工作小时数乘以每小时工资。否则，薪水包括160小时的工资以及超过160小时的部分，超过部分按每小时工资的1.5倍计算。最后,该方法返回计算得到的月薪加上父类 `Employee` 提供的月薪。 class SalesEmployee 继承自 Employee 类。 它包含两个私有成员变量：销售额 sales 和销售率 rate。 SalesEmployee 类构造函数接受员工姓名 name、出生日期 birth、销售额 sales 和销售率 rate 作为参数，并使用 super(name, birth) 调用父类 Employee 类的构造函数进行初始化。 随后，该类将私有变量 sales 和 rate 分别设置为传入的销售额和销售率。 SalesEmployee 类提供了一个 getSalary 方法，该方法根据月度工作时长 month 返回员工的总薪水。 计算方式为：sales 乘以 rate 再加上调用父类 Employee 类的 getSalary 方法返回的月薪。 该类 `BasedPlusSalesEmployee` 继承自 `SalesEmployee` 类。它包含一个私有整数变量 `basedSalary`，用于存储基本工资。构造函数 `BasedPlusSalesEmployee` 接受员工姓名、出生日期、销售额、提成率和基本工资作为参数，并调用父类的构造函数进行初始化，同时将 `basedSalary` 赋值给实例变量。 该类提供了 `getSalary` 方法，用于计算月薪，该月薪由基本工资、通过父类继承的月薪以及额外的工资组成。此外，还定义了一个名为 `getAddtionalSalary` 的方法，该方法返回一个固定的值 1000。 经典算法： 1. 一所学校为其学生安排宿舍，规定每6位学生占用一间房间，且不考虑学生的性别差异。因此，需要准备多少间房间以满足所有学生的住宿需求？ 答案： (x+5) * 6 请注意理解整数类型的数值运算。 2. 让数值在 0～9 之间循环。 public class test{ public static void main(String[] args){ int i=0; while(true){ i = (i+1)%10; System.out.println(i); } } } 作业： 1. 设计一个数组类，用于存储对象： 该类应具备以下功能：添加（允许添加任意数量的元素）、修改现有元素、在指定位置插入新元素、删除指定位置的元素以及查询特定位置或满足条件的元素。 ```java class MyArray { private Object[] os = new Object[10]; public void add(Object o) { /* 实现添加功能 */ } public void set(int index, Object o) { /* 实现修改功能 */ } public void insert(int index, Object o) { /* 实现插入功能 */ } public void remove(int index) { /* 实现删除功能 */ } public void remove(Object o) { /* 实现删除指定对象的功能 */ } public Object get(int index) { /* 实现查询功能 */ } } ``` } public class TestMyArray { public static void main(String[] args) { MyArray ma = new MyArray(); ma.add(aaa); ma.add(bbb); ma.add(ccc); Object o = ma.get(1); Iterator it = ma.iterator(); while (it.hasNext()) { Object o1 = it.next(); System.out.println(o1); } } } 作业 10-08 1. 生成包含 20 个随机整数（范围在 10 以内）的 ArrayList，随后利用迭代器对该 ArrayList 进行遍历。 2. 接着，从 ArrayList 中移除所有值为 5 的元素。 3. 之后，生成另外三个整数，并将它们插入到 ArrayList 的第 4 个位置。 4. 最后，将 ArrayList 中所有值为 1 的数字替换为 10。 import java.util.ArrayList; class ArrayList { private Object[] os = new Object[20]; } public class TestArray { public static void main(String[] args) { ArrayList全部评论 (0)
