Java期末测试题

编写代码，声明一个名为Person的类，里面声明name与age两个属性，定义talk()方法返回姓名和年龄信息；

声明一个学生类Student，继承自Person类，添加school属性，声明带三个参数的构造方法，复写talk()方法，在该方法中调用父类的talk()方法，返回姓名、年龄和学校信息；实例化子类对象stu，调用talk()方法打印“我是：张三，今年：18岁，我在华北水利水电大学上学。”

声明一个员工类Employee，继承自Person类，添加employer属性，声明带三个参数的构造方法，复写talk()方法，在该方法中调用父类的talk()方法，返回姓名、年龄和工作信息；实例化子类对象emp，调用talk()方法打印“我是：李四，今年：28岁，我在腾讯公司工作。”

要求代码格式规范，注释清晰完整。

//定义抽象类Person
public abstract class Person{
    //定义name属性
    private String name;
    //定义age属性
    private int age;
    //构造无参方法
    public Person(){

    }
    //构造有参方法
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    //age赋值方法
    public void setAge(int age) {
        this.age = age;
    }
    //name赋值方法
    public void setName(String name) {
        this.name = name;
    }
    //获取name
    public String getName() {
        return name;
    }
    //获取age
    public int getAge() {
        return age;
    }
    public String  talk(){
        return "我是："+name+"，"+"今年："+age+"岁，";
    }

}
public class Student extends Person {
    private String school;
    //构造无参方法
    public Student(){

    }
    public Student(String name, int age, String school) {
        // 调用父类构造方法初始化name和age属性
        super(name, age);
        // 初始化school属性
        this.school = school;
    }
    @Override
    public String talk() {
        return super.talk()+"我在"+school+"上学。";
    }
}
public class Student extends Person {
    private String school;
    //构造无参方法
    public Student(){

    }
    public Student(String name, int age, String school) {
        // 调用父类构造方法初始化name和age属性
        super(name, age);
        // 初始化school属性
        this.school = school;
    }
    //重写talk方法
    @Override
    public String talk() {
        return super.talk()+"我在"+school+"上学。";
    }
}
public class Employee extends Person {
    //定义employer属性
    private String employer;
    //构造无参方法
    public Employee (){

    }
    public Employee (String name, int age, String employer) {
        // 调用父类构造方法初始化name和age属性
        super(name, age);
        // 初始化employee属性
        this.employer = employer ;
    }
    //重写talk方法
    @Override
    public String talk() {
        return super.talk()+"我在"+employer+"工作。";
    }
}
public class test1 {
    public static void main(String[] args){
        //实例化子类对象stu
        Student stu = new Student("张三",18,"华北水利水电大学");
        //实例化子类对象emp
        Employee emp=new Employee("李四",28,"腾讯公司");
        //打印信息
        System.out.println(stu.talk() );
        System.out.println(emp.talk() );
    }
}

 

编写程序，从键盘输入两个数，要求不能输入负数，计算两个数相除的值并输出。

要求:对以下异常进行捕捉：

数据类型不一致：NumberFormatException

除0：ArithmeticException

输入负数（自定义异常）：InputMinusException

要求代码格式规范，注释清晰完整。

import java.util.*;
import java.util.Scanner;

public class Exce {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入第一个数：");
        int n1 = scanner.nextInt() ;
        System.out.println("输入第二个数：");
        int n2 = scanner.nextInt();
        try {
            //判断是否为负数
            if (n1 < 0 || n2 < 0) {
                throw new InputMinusException("输入的数字不能为负数");
            }
            //判断除数是否为0
            if (n2 == 0) {
                throw new ArithmeticException("除数不能为0");
            }
            //强制类型转换
            double result = (double) n1 / n2;
            //根据结果判断异常并输出
            System.out.println("结果是：" + result);
        } catch (NumberFormatException e) {
            System.out.println("数据类型不一致");
        } catch (InputMinusException e) {
            System.out.println("输入负数：" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("除0异常：" + e.getMessage());
        }
    }
}
//自定义异常需要继承Exception
class InputMinusException extends Exception {
    //调用无参构造方法
    public InputMinusException (){

    }
    //调用有参构造方法
    public InputMinusException(String message) {
        super(message);
    }
}

 

请使⽤ArrayList来模拟⼀个队列用来存放字符串，队列具有先进先出的特性。要求如下:

（1）拥有放⼊对象的⽅法void put(String s)

（2）取出对象的⽅法String get()

（3）判断队列当中是否为空的⽅法boolean isEmpty()；并且，编写测试代码，验证你的队列是否正确。

要求代码格式规范，注释清晰完整。

import java.util.ArrayList;

public class Array<String> {
    private ArrayList<String> queue;

    // 构造函数
    public Array() {
        queue = new ArrayList<>();
    }

    // 添加元素到队尾
    public void put(String s) {
        queue.add(s);
    }

    // 从队头取出元素，如果队列为空则返回null
    public String get() {
        if (queue.isEmpty()) {
            return null;
        } else {
            return queue.remove(0);
        }
    }

    // 检查队列是否为空
    public boolean isEmpty() {
        return queue.isEmpty();
    }
}
public class test2 {
    public static void main(String[] args){
        Array<String> queue = new Array<>() ;
        queue.put("3");
        System.out.println(queue.get() );
        System.out.println(queue.isEmpty());
    }
}

 

输入一个由英文字母组成的字符串s，找到s中最长的回文子串并输出。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

要求代码格式规范，注释清晰完整。

示例 1：

输入："babad"

输出："bab"

解释："aba" 同样是符合题意的答案。

示例 2：

输入："cbbd"

输出："bb"

//导入java工具类
import java.util.*;
//定义test类
 class test{
     //定义一个round方法用来判断最长的回文字符串
    public static String round(String s){
        //如果字符串为空或字符串长度小于2则返回字符串本身
        if (s == null||s.length()<2 ){
            return s;
        }
        //定义两个查找变量
        int begin=0;
        int end=0;
            //for循环对字符串进行遍历
            for (int i = 0; i < s.length(); i++) {

                int m= i+1;
                int n=i-1;
                //如果s.m和s.n相等，并且子串s[m, n]也是回文串，那么s[m, n]就是回文串
                while(m<s.length()&&n>=0&&s.charAt(m)==s.charAt(n)){
                    m++;
                    n--;
                }
                // 如果当前子串比已知的最长回文子串要长，那么更新最长回文子串
                if(m-n-1>end-begin-1){
                    begin=n;
                    end=m-1;
                }
            }
        //使用substring对字符串进行截取并返回最长的回文字符串
        return s.substring(begin,end+1);
    }
    public static void main(String[] args){
         Scanner sc = new Scanner(System.in);
         String str = sc.next();
         //输出回文字符串
         System.out.println(round(str));
     }
 }

编写代码，输入一句英文句子，生成一个新的字符串，使每个单词的首字母都转换为大写，并输出。要求代码格式规范，注释清晰完整。

示例：

输入："let there be light."

输出："Let There Be Light."

//导入Java工具类
import java.util.*;
public class two {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        //定义输入的字符串
        String input = sc.nextLine();
        //将output字符串先置为空
        String out = "";
        //将输入的字符串转化为数组
        char[] chars = input.toCharArray();

        //遍历判断是否是首字母
        for(int i = 0; i <chars.length; i++) {
            //单词首字母的标准为首字母前面是否为空格或者长度为0
            if(i == 0||chars[i-1] == ' ' ) {
                //将字符转换为大写
                chars[i]=Character.toUpperCase(chars[i]);
            }
            else {
                //不是首字母的保存原样
                chars[i]=chars[i];
            }
        }
        //将数组转为字符串输出
        out=new String(chars);
        //输出修改后的字符串
        System.out.println(out);
    }

}

一个盒子中有四种颜色的小球，其中红色5个，黑色2个，黄色7个，蓝色6个。用HashMap记录每种颜色小球的个数，并实现以下操作：

（1）找出数量最多和数量最少的小球颜色，将结果打印在屏幕上；

（2）按照每种颜色小球数量由多到少的顺序，将各种颜色依次打印在屏幕上。

要求代码格式规范，注释清晰完整。

import java.util.HashMap;  
import java.util.Map;  
  
public class Main {  
    public static void main(String[] args) {  
        // 创建一个HashMap记录每种颜色小球的数量  
        Map<String, Integer> ballMap = new HashMap<>();  
        ballMap.put("红色", 5);  
        ballMap.put("黑色", 2);  
        ballMap.put("黄色", 7);  
        ballMap.put("蓝色", 6);  
  
        // 找出数量最多和数量最少的小球颜色  
        String maxColor = "";  
        String minColor = "";  
        int maxCount = Integer.MIN_VALUE;  
        int minCount = Integer.MAX_VALUE;  
        for (Map.Entry<String, Integer> entry : ballMap.entrySet()) {  
            String color = entry.getKey();  
            int count = entry.getValue();  
            if (count > maxCount) {  
                maxCount = count;  
                maxColor = color;  
            }  
            if (count < minCount) {  
                minCount = count;  
                minColor = color;  
            }  
        }  
        System.out.println("数量最多的小球颜色是：" + maxColor);  
        System.out.println("数量最少的小球颜色是：" + minColor);  
  
        // 按照每种颜色小球数量由多到少的顺序，将各种颜色依次打印在屏幕上  
        ballMap.entrySet().stream()  
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())  
                .forEachOrdered(entry -> System.out.println(entry.getKey()));  
    }  
}