持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第 29 天，点击查看活动详情
文章首发地址：村雨遥
JAVA21 补全构造方法
描述
有父类 Base，内部定义了 x、y 属性。有子类 Sub，继承自父类 Base。子类新增了一个 z 属性，并且定义了 calculate 方法，在此方法内计算了父类和子类中 x、y、z 属性三者的乘积。请补全子类构造方法的初始化逻辑，使得该计算逻辑能够正确执行。
输入描述
三个整数：x, y, z
输出描述
三个整数的乘积：xyz
示例1
输入：
1 2 3
输出：
解答
主要考察 super 关键字的运用，Sub 是子类，所以在初始化构造器时，需要先用 super 继承父类 Base 中的构造方法。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
Sub sub = new Sub(x, y, z);
System.out.println(sub.calculate());
}
}
}
class Base {
private int x;
private int y;
public Base(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
}
class Sub extends Base {
private int z;
public Sub(int x, int y, int z) {
super(x, y);
this.z = z;
}
public int getZ() {
return z;
}
public int calculate() {
return super.getX() * super.getY() * this.getZ();
}
}
JAVA22 重写计算逻辑
描述
在父类 Base 中定义了计算方法 calculate()，该方法用于计算两个数的乘积（X*Y）。请在子类Sub中重写该方法，将计算逻辑由乘法改为除法（X/Y）。注意，当分母为0时输出 “Error”。
输入描述
两个整数
输出描述
两个整数的商(int类型，不考虑小数情况)
示例1
输入：
6 2
复制
输出：
3
复制
示例2
输入：
1 0
复制
输出：
Error
解答
首先，既然是继承，那么要继承父类的构造方法，然后就是利用条件语句 if...else... 进行重写 calculate() 方法。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
Sub sub = new Sub(x, y);
sub.calculate();
}
}
}
class Base {
private int x;
private int y;
public Base(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void calculate() {
System.out.println(getX() * getY());
}
}
class Sub extends Base {
public Sub(int x, int y) {
super(x, y);
}
public void calculate() {
if (getY() == 0)
System.out.println("Error");
else
System.out.println(getX() / getY());
}
}
JAVA23 定义打印方法
描述
已知有三个类：First、Second、Third。要求定义一个打印方法，支持传入任意引用类型的参数（包括上述三个类），并在方法内部打印出对象的字符串形式。
输入描述
类名
输出描述
由该类实例化出来的对象的字符串表示
示例1
输入：
First
复制
输出：
First
解答
和简单的方法没啥两样，主要区别在于传参的类型，平常传参我们都是传的具体的类，但是这里传的参是一个 Object 类型，表示我们可以传任意类型的参数。
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String className = scanner.next();
// print就是需要你定义的方法
print(Class.forName(className).newInstance());
}
}
public static void print(Object obj) {
System.out.print(obj.toString());
}
}
class First {
public String toString() {
return "First";
}
}
class Second {
public String toString() {
return "Second";
}
}
class Third {
public String toString() {
return "Third";
}
}
JAVA24 类型判断
描述
父类Base有两个子类：Sub1、Sub2，现有一个方法getClassName()，要求传入Base类型的实例，在方法内部判定其具体的类型，返回的是类型的简单名字（不含包名），请补全getClassName()方法的判断逻辑。
输入描述
输入要实例化的类名：Base、Sub1、Sub2 三者之一。
输出描述
返回实例的实际类名（简化类名，不包含包的名字）。
示例1
输入：
Sub1
复制
输出：
Sub1
复制
示例2
输入：
Sub2
复制
输出：
Sub2
复制
示例3
输入：
Base
复制
输出：
Base
解答
利用关键字 instanceof 判断一个对象是否属于某个类，接着调用 Object 类的 getClass() 方法来获得 Class 对象，最后用 getSimpleName() 方法就可以或者获取这个对象所属类的名称。
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String className = scanner.next();
Base obj = (Base) Class.forName(className).newInstance();
System.out.println(getClassName(obj));
}
}
public static String getClassName(Base obj) {
if (obj instanceof Sub1) {
Sub1 sub1 = (Sub1) obj;
return sub1.getClass().getSimpleName();
} else if (obj instanceof Sub2) {
Sub2 sub2 = (Sub2) obj;
return sub2.getClass().getSimpleName();
} else {
return obj.getClass().getSimpleName();
}
}
}
class Base {
}
class Sub1 extends Base {
}
class Sub2 extends Base {
}
JAVA25 实现抽象方法
描述
已知抽象类Base中定义了calculate方法，该方法的计算过程依赖于sum()和avg()，而后两个方法均为抽象方法。要求定义Base的子类Sub类，并实现父类的抽象方法，使得main函数中的运算逻辑得以正确执行。
输入描述
两个整数
输出描述
两个整数的和除以两个整数的平均值（平均值为int类型，不考虑小数问题）
示例1
输入：
1 2
复制
输出：
3
解答
主要就是考察继承的知识点，继承了抽象方法，那么此时只需要对方法进行重写即可。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Sub是需要你定义的子类
Base base = new Sub();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
base.setX(x);
base.setY(y);
System.out.println(base.calculate());
}
}
}
abstract class Base {
private int x;
private int y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public int calculate() {
if (avg() == 0) {
return 0;
} else {
return sum() / avg();
}
}
/**
* 返回x和y的和
*/
public abstract int sum();
/**
* 返回x和y的平均值
*/
public abstract int avg();
}
class Sub extends Base {
public int sum() {
return super.getX() + super.getY();
}
public int avg() {
return sum() / 2;
}
}
