JAVA期末考试编程大题＋简答(KSU)

最新推荐文章于 2024-07-27 13:31:57 发布

Network_Engineer

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量228

点赞数 9

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Network_Engineer/article/details/140232072

版权

本文章题目仅适用于ksu期末考试使用,如发现错误,可私信交流,欢迎指正

计程车计费问题

import java.util.*;
public class Demo1 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        double km = sc.nextDouble();
        int price = 0;
        if(km <= 6){
            price = 3;
        }else if( 6<km && km <=12){
            price = 4;
        }else if(12<km && km <=22){
            price = 5;
        }else if(22<km && km <=32){
            price = 6;
        }else{
            price =6 + (int) Math.ceil((km-32)/20);
        }
        System.out.println(price);
    }
}

长方形

class Rectangle1{
    private double chang, kuan;
    public Rectangle1(){
    }
    public Rectangle1(double chang, double kuan){
        this.chang = chang;
        this.kuan = kuan;
    }
    public double getArea(){
        return chang * kuan;
    }
    public double getCircum(){
        return 2 * (chang + kuan);
    }
}
public class TestRectangle {
    public static void main(String[] args){
        Rectangle1 rec1 = new Rectangle1(5, 3);
        System.out.println(rec1.getArea());
        System.out.println(rec1.getCircum());
    }
}

人类（继承）

class Person{
    private String name;
    private int age;
    public Person(){
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void Eat(){
        System.out.println("人正在吃饭");
    }
    public void Sleep(){
        System.out.println("人正在睡觉");
    }
}
class Student extends Person{
    public void Study(){
        System.out.println("学生正在学习");
    }
}
class Teacher extends Person {
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
    public void Teach() {
        System.out.println("老师正在上课");
    }
}

人类学生（继承）

class Person{
    private String name;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Student extends Person{
    public Student(){}
    public Student(String name, int grade){
        super(name);
        this.grade = grade;
    }
    private int grade;
    public void setGrade(int grade){
        this.grade = grade;
    }
    public int getGrade(){
        return grade;
    }
}
public class Test {
    public static void main(String[] args){
        Student s = new Student("Bob", 99);
        System.out.println(s.getGrade());
        System.out.println(s.getName());
    }
}

接口

interface Shape{
    double getArea();
}
class Circle implements Shape{
    private double Radius;
    public Circle(){}
    public Circle( double Radius){
        this.Radius = Radius;
    }
    public double getArea(){
        return Math.PI * Radius * Radius;
    }
}
class Rectangle implements Shape{
    private double width;
    private double height;
    public Rectangle(){}
    public Rectangle( double width, double height){
        this.width = width;
        this.height = height;
    }
    public double getArea(){
        return width * height;
    }
}
public class InterfaceTest {
    public static void main(String[] args){
        Circle c = new Circle(5);
        Rectangle r = new Rectangle(5, 7);
        System.out.println(c.getArea());
        System.out.println(r.getArea());
    }
}

多态

class Animal {
    public void move() {
        System.out.println("我可以move...");
    }
}
class Bird extends Animal {
    public void move() {
        System.out.println("我在天空飞翔...");
    }
    public void singing() {
        System.out.println("鸟儿会清脆地歌唱...");
    }
}
class Fish extends Animal {
    public void move() {
        System.out.println("我在水里游泳...");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        a1.move();
        Animal a2 = new Bird(); // 子类对象送给父类引用
        a2.move();
        Animal a3 = new Fish();
        a3.move();
    }
}

字母计数器 HashMap

import java.util.*;

public class jishuqi {
    public static void main(String[] args) {
        System.out.println("请输入需要统计的字符串：");
        Scanner scanner = new Scanner(System.in);
        String message = scanner.nextLine();
        HashMap<Character, Integer> map = new HashMap();
        for (int i = 0; i < message.length(); i++) {
            char ch = message.charAt(i);
            if (map.containsKey(ch)) {
                map.put(ch, map.get(ch) + 1);
            } else {
                map.put(ch, 1);
            }
        }
        //System.out.println(map);
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        Iterator iterator = set.iterator();
        //觉得复杂也可以只背下面的注释部分
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            char key = entry.getKey();
            int value = entry.getValue();
            System.out.println("键" + key + ":" + value);
        }
    }
}

HashMap注释版

import java.util.*;

// 定义一个类jishuqi
public class jishuqi {
    // main方法是程序的入口
    public static void main(String[] args) {
        // 提示用户输入需要统计的字符串
        System.out.println("请输入需要统计的字符串：");

        // 创建Scanner对象用于接收用户输入
        Scanner scanner = new Scanner(System.in);
        // 读取用户输入的字符串
        String message = scanner.nextLine();

        // 创建一个HashMap对象用于统计字符出现的次数
        HashMap<Character, Integer> map = new HashMap<>();

        // 遍历输入字符串的每一个字符
        for (int i = 0; i < message.length(); i++) {
            char ch = message.charAt(i); // 获取当前字符
            // 如果字符已经在map中，更新其计数
            if (map.containsKey(ch)) {
                map.put(ch, map.get(ch) + 1);
            } else {
                // 如果字符不在map中，添加并将计数设为1
                map.put(ch, 1);
            }
        }

        // 获取map中的所有键值对（字符及其对应的计数）
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        // 创建一个迭代器用于遍历键值对
        Iterator<Map.Entry<Character, Integer>> iterator = set.iterator();
        // 使用迭代器遍历所有的键值对并打印出来
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 使用增强型for循环遍历所有的键值对并打印出来
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            char key = entry.getKey(); // 获取键（字符）
            int value = entry.getValue(); // 获取值（字符计数）
            System.out.println("键" + key + ":" + value);
        }
    }
}

简答题

- 什么是静态成员？静态成员有什么特征？
    由static这个关键字来声明的数据成员就叫做静态成员。
    Static数据成员通常是为类的对象所共享的数据，static方法通常是工具方法，不必创建对象直接使用类名即可调用。
    Static成员属于类而不是对象，被main直接调用。


- 简述什么是方法重写？！！！！
    方法重写（Method Overriding）是面向对象编程中的重要概念。子类继承父类后，可以重新定义父类的方法以实现特定功能。方法重写遵循“两同两小一大”的规则：
    两同：方法名称相同、参数列表相同。
    两小：子类方法返回值类型小于或等于父类方法的返回值类型，子类方法抛出的异常范围小于或等于父类方法的异常范围。
    一大：子类方法的访问权限大于或等于父类方法的访问权限。
    此外，方法的`static`或`非static`性质不能改变。

- 简述抽象类的基本概念
    在面向对象的设计中，所有的对象都是通过类来描绘，但是反之并不成立，并不是所有的类都是用来描绘对象的。如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。


- 简述多态的概念
	继承
	重写
	父类引用指向子类对象
	多态性是指在继承层次结构中，父类中定义的行为被子类继承重写后所表现出的不同的效果，它使得同一个行为在父类及其各个子类中具有不同的语义。


- 简述异常捕获及处理
    当程序运行出现意外时，Java 自动生成（或由程序设计者生成)Exception 对象来通知程序，程序在独立的语向块中对异常进行处理，由此实现了 “业务功能实现代码” 和 “异常处理代码”的分离。


- 简述集合中框架结构以及特点！！！！
    Java集合框架的根接口是Collection和Map。Collection接口是Set、Queue和List接口的父接口；Map以键值对的映射关系存储集合。
    List：有序集合，记录元素添加顺序，允许重复元素。
    Set：无序集合，不记录添加顺序，元素不可重复。
    Map：键值对集合，每个元素由键（无序集合Set）和值（有序集合List）组成。