Java从0到1入门|面向对象
【摘要】 一、修改Data类的定义描述现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。输入描述：两个整数输出描述：两个整数的和示例1输入：1 2输出：3题解：import java.util.Scanner;public class Ma...
一、修改Data类的定义
描述
现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。
输入描述：
两个整数
输出描述：
两个整数的和
示例1
输入：
1 2
输出：
3
题解：
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();
Data data = new Data(x, y);
System.out.println(data.getX() + data.getY());
}
}
}
class Data {
private int x;
private int y;
public Data(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
}
二、验证年龄
描述
采用封装的思想，为Person类定义年龄属性，要求：
修改年龄时判断其范围，若年龄小于0则按0输出，若年龄大于200则按200输出。
输入描述：
年龄整数值
输出描述：
1. 若年龄小于0则输出0；
2. 若年龄大于200则输出200；
3. 若年龄介于[0,200]之间则直接输出。
示例1
输入：
25
输出：
25
示例2
输入：
-25
输出：
0
示例3
输入：
250
输出：
200
题解：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Person p = new Person();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int age = scanner.nextInt();
p.setAge(age);
System.out.println(p.getAge()>=200?200:
p.getAge()<=0?0:p.getAge());
}
}
}
class Person {
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge()
{
return this.age;
}
}
三、补全构造方法
描述
有父类Base，内部定义了x、y属性。有子类Sub，继承自父类Base。子类新增了一个z属性，并且定义了calculate方法，在此方法内计算了父类和子类中x、y、z属性三者的乘积。请补全子类构造方法的初始化逻辑，使得该计算逻辑能够正确执行。
输入描述：
三个整数：x, y, z
输出描述：
三个整数的乘积：x*y*z
示例1
输入：
1 2 3
输出：
6
题解：
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;
Base() {
}
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(){};
public Sub(int x, int y, int z) {
super(x,y);
this.z=z;
}
public Sub(int x, int y) {
super(x, y);
}
public int getZ() {
return z;
}
public int calculate() {
return super.getX() * super.getY() * this.getZ();
}
}
四、重写计算逻辑
描述
在父类Base中定义了计算方法calculate()，该方法用于计算两个数的乘积（X*Y）。请在子类Sub中重写该方法，将计算逻辑由乘法改为除法（X/Y）。注意，当分母为0时输出“Error”。
输入描述：
两个整数
输出描述：
两个整数的商(int类型，不考虑小数情况)
示例1
输入：
6 2
输出：
3
示例2
输入：
1 0
输出：
Error
题解：
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 {
//write your code here......
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());
}
}五、定义打印方法
描述
已知有三个类：First、Second、Third。要求定义一个打印方法，支持传入任意引用类型的参数（包括上述三个类），并在方法内部打印出对象的字符串形式。
输入描述：
类名
输出描述：
由该类实例化出来的对象的字符串表示
示例1
输入：
First
输出：
First
题解：
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());
}
}
//write your code here......
public static void print(Object obj){//Object类属于抽象类，以它作为引用可以引用任何类
System.out.println(obj.toString());//调用toString方法即可获取类名的字符串形式
}
}
class First {
public String toString() {
return "First";
}
}
class Second {
public String toString() {
return "Second";
}
}
class Third {
public String toString() {
return "Third";
}
}
六、类型判断
描述
父类Base有两个子类：Sub1、Sub2，现有一个方法getClassName()，要求传入Base类型的实例，在方法内部判定其具体的类型，返回的是类型的简单名字（不含包名），请补全getClassName()方法的判断逻辑。
输入描述：
输入要实例化的类名：Base、Sub1、Sub2 三者之一。
输出描述：
返回实例的实际类名（简化类名，不包含包的名字）。
示例1
输入：
Sub1
输出：
Sub1
示例2
输入：
Sub2
输出：
Sub2
示例3
输入：
Base
输出：
Base
题解：
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) {
//write your code here......
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 {
}
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）