【牛客网刷题】java基础语法篇（二）

发布于：2022-12-07 ⋅ 阅读:(879) ⋅ 点赞:(0)

文章目录

1. JAVA19 修改Data类的定义（对象）

描述
现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。
输入描述：
两个整数
输出描述：
两个整数的和

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int x = in.nextInt();
            int y = in.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;
    }
}

2. JAVA20 验证年龄（对象）

描述
采用封装的思想，为Person类定义年龄属性，要求：
修改年龄时判断其范围，若年龄小于0则按0输出，若年龄大于200则按200输出。
输入描述：
年龄整数值
输出描述：

  1. 若年龄小于0则输出0；
  2. 若年龄大于200则输出200；
  3. 若年龄介于[0,200]之间则直接输出。
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int age = in.nextInt();
        Person person = new Person(age);
        System.out.println(person.getAge());
    }
}
class Person {
    private int age = 0;
    Person(int age) {
        if (age < 0) {
            this.age = 0;
        } else if (age > 200){
            this.age = 200;
        } else {

            this.age = age;
        }
    }
    public int getAge() {
        return this.age;
    }
}

3. JAVA21 补全构造方法（继承）

描述
有父类Base，内部定义了x、y属性。有子类Sub，继承自父类Base。子类新增了一个z属性，并且定义了calculate方法，在此方法内计算了父类和子类中x、y、z属性三者的乘积。请补全子类构造方法的初始化逻辑，使得该计算逻辑能够正确执行。
输入描述：
三个整数：x, y, z
输出描述：
三个整数的乘积：xyz

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int x = in.nextInt();
        int y = in.nextInt();
        int z = in.nextInt();
        Sub sub = new Sub(x, y, z);
        System.out.println(sub.calculate());
    }
}
class Base {
    private int x;
    private int y;
    Base(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return this.x;
    }
    public int getY() {
        return this.y;
    }
}
class Sub extends Base {
    private int z;
    Sub(int x, int y, int z) {
        super(x, y);
        this.z = z;
    }
    public int getZ() {
        return this.z;
    }
    public int calculate() {
        return this.z * this.getX() * this.getY();
    }
    
}

4. JAVA22 重写计算逻辑（重写）

描述
在父类Base中定义了计算方法calculate()，该方法用于计算两个数的乘积（X*Y）。请在子类Sub中重写该方法，将计算逻辑由乘法改为除法（X/Y）。注意，当分母为0时输出“Error”。
输入描述：
两个整数
输出描述：
两个整数的商(int类型，不考虑小数情况)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int x = in.nextInt();
        int y = in.nextInt();
        if(x == 0)  {
            System.out.println(0);
            return ;
        }
        Sub sub = new Sub(x, y);
        System.out.println(sub.calculate() == 0?"Error":sub.calculate());
    }
}
class Base {
    private int x;
    private int y;
    Base(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return this.x;
    }
    public int getY() {
        return this.y;
    }
    public int calculate() {
        return this.x * this.y;
    }
}
class Sub extends Base {

    Sub(int x, int y) {
        super(x, y);
    }
    public int calculate() {
        int y = super.getY();
        int x = super.getX();

        if (y != 0) {
            return x / y;
        } else {
            return 0;
        }
    }

}

5. JAVA23 定义打印方法（多态）

描述
已知有三个类：First、Second、Third。要求定义一个打印方法，支持传入任意引用类型的参数（包括上述三个类），并在方法内部打印出对象的字符串形式。
输入描述：
类名
输出描述：
由该类实例化出来的对象的字符串表示

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String str = in.next();
        Base b; 
        if(str.equals ("First")) {
            b = new First();
        } else if(str.equals ("Second")) {
            b = new Second();
        } else {
            b = new Third();
        }
        b.prints();
    }
}
class Base {
    public void prints() {
    }
}
class First extends Base {
    public void prints() {
        System.out.println("First");
    }

}
class Second extends Base {
    public void prints() {
        System.out.println("Second");
    }

}
class Third extends Base {
    public void prints() {
        System.out.println("Third");
    }

}

6. JAVA24 类型判断（多态）

描述
父类Base有两个子类：Sub1、Sub2，现有一个方法getClassName()，要求传入Base类型的实例，在方法内部判定其具体的类型，返回的是类型的简单名字（不含包名），请补全getClassName()方法的判断逻辑。
输入描述：
输入要实例化的类名：Base、Sub1、Sub2 三者之一。
输出描述：
返回实例的实际类名（简化类名，不包含包的名字）。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.next();
        Base b; 
        if (str.equals ("Sub1")) {
            b = new Sub1();
        } else if (str.equals ("Sub2")) {
            b = new Sub2();
        } else {
            b = new Base();
        }
        b.getClassName();
    }
}

class Base {
    public void getClassName() {
        System.out.println("Base");
    }
}
class Sub1 extends Base {
    public void getClassName() {
        System.out.println("Sub1");
    }
}
class Sub2 extends Base {
    public void getClassName() {
        System.out.println("Sub2");
    }
}

7. JAVA25 实现抽象方法（抽象）

描述
已知抽象类Base中定义了calculate方法，该方法的计算过程依赖于sum()和avg()，而后两个方法均为抽象方法。要求定义Base的子类Sub类，并实现父类的抽象方法，使得main函数中的运算逻辑得以正确执行。
输入描述：
两个整数
输出描述：
两个整数的和除以两个整数的平均值（平均值为int类型，不考虑小数问题）

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int x = in.nextInt();
        int y = in.nextInt();
        Sub sub = new Sub(x, y);
        System.out.println(sub.calculate());
    }
}
abstract class Base {
    private int x;
    private int y;
    Base(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public abstract int avg();
    public abstract int sum();
    public int calculate() {
        if (avg() == 0) {
            return 0;
        } else {
            return sum() / avg();
        }
    }
}
class Sub extends Base {
    Sub(int x, int y) {
        super(x, y);
    }
    public int avg() {
        return (super.getX() + super.getY()) / 2;
    }
    public int sum() {
        return super.getX() + super.getY();
    }
}

8. JAVA26 实现接口（接口）

描述
已知接口Comparator，内部定义了max函数，用于返回两个整数中的最大值。请定义该接口的实现类，使得main方法中的比较逻辑可以正确执行，要求实现类的名称为ComparatorImpl。
输入描述：
两个整数
输出描述：
两个整数中的最大值

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        Sub sub = new Sub(a,b);
        System.out.println(sub.max());
    }
}

interface Comparator {
    public int max();
}
class Sub implements Comparator {
    private int a;
    private int b;
    Sub(int a,int b) {
        this.a = a;
        this.b = b;
    }
    public int max() {
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

9. JAVA27 重写父类方法（重写）

描述
父类Base中定义了若干get方法，以及一个sum方法，sum方法是对一组数字的求和。请在子类 Sub 中重写 getX() 方法，使得 sum 方法返回结果为 x*10+y
输入描述：
整数
输出描述：
整数的和

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
            int x = in.nextInt();
            int y = in.nextInt();
            Sub sub = new Sub(x,y);
            System.out.println(sub.sum());
    }
}
class Base {
    private int x;
    private int y;
    Base(int x,int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return this.x;
    }
    public int getY() {
        return this.y;
    }
    public int sum() {
        return getX() + getY();
    }
}
class Sub extends Base {
    Sub(int x,int y) {
        super(x,y);
    }
    
    public int getX() {
        return super.getX() * 10;
    }
}

10. JAVA28 创建单例对象

描述
Singleton类是单例的，每次调用该类的getInstance()方法都将得到相同的实例，目前该类中这个方法尚未完成，请将其补充完整，使得main()函数中的判断返回真（不考虑线程安全）。
输入描述：
无
输出描述：
true

public class Main {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }

}

class Singleton {

    private static Singleton instance;

    private Singleton() {

    }
public static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}
    //write your code here......


}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布