期末测试编程题

编程题第一题

package step1;
/**
 * 声明一个学生类，其数据成员为姓名、编号（利用静态变量实现自动编号）、年龄，
 * 并拥有静态数据成员count,用于记录学生的人数
 * 在构造方法中利用此静态变量为对象的编号赋值，在主方法中定义多个对象，并求出总的学生数。
 * 运行输出结果：
 * 学生编号：1、姓名：匿名、年龄：20
 * 学生编号：2、姓名：张三、年龄：21
 * 学生总人数：2
 */
class Student {
	private int sid ;	// 编号
	private String name ;	// 姓名
	private int age ;	// 年龄
	private static int count = 0 ; //定义静态成员变量count，记录学生总人数
	
	public Student() {
		this.sid = count + 1; //自动编号
		this.name = "匿名";
		this.age = 20;
		count ++;
	}
	
	public Student(String name, int age) {
		//【补全代码，不限行数】
        this.name = name;
        this.age = age;
        this.sid = count + 1;

	}
	
	public void printInfo() {
		System.out.println("学生编号：" + this.sid + "、姓名：" + this.name + "、年龄：" + this.age );
	}
	
	//【补全代码】
    public static int getCount()
    { //定义静态成员函数getCount()，返回
        count = count+1;
		return count ;
	}
}
public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.printInfo();
		
		Student s2 = new Student("张三",21);//【补全代码】; // 学生姓名 "张三", 年龄 21
		s2.printInfo();//【补全代码】; //输出学生s2的信息

		System.out.println("学生总人数：" + Student.getCount()) ;
	}
}

编程题第二题

package step2;

/**
 * 定义员工类Employee，拥有成员变量name，age，salary，分别表示姓名、年龄、月薪
 * 定义程序员类Programmer，继承Employee类，新增成员变量bonus，表示奖金
 * 定义实习生类Intern，继承Employee类，新增成员变量workingDays，dailyWage，分表表示工作天数，日薪
 */

class Employee { // 定义员工类
	private String name;	//姓名
	private int age;		//年龄
	protected double salary; //月薪

	Employee(String name, int age) {
		this.name = name;
		this.age = age; 
	}

	public void showInfo() {
		System.out.println("姓名：" + this.name);
		System.out.println("年龄：" + this.age);
		System.out.println("月薪：" + this.salary); 
	}
}

class Programmer extends Employee{  // 定义程序员类Programmer，继承员工类Employee
	private double bonus; //奖金
		
	Programmer(String name, int age, double salary, double bonus){
		super(name, age);// 调用父类构造方法
		this.salary = salary;
		this.bonus = bonus;
	}

	public void showInfo() { // 覆盖override父类的showInfo()方法
		System.out.println("【程序员】");
		super.showInfo();	// 调用父类的showInfo()，以显示姓名、年龄、月薪的信息
		System.out.println("奖金：" + this.bonus);
	}
}

class Intern extends Employee {  // 定义实习生类Intern，继承员工类Employee
	private int workingDays; // 工作天数
	private double dailyWage; //日薪

	Intern(String name, int age, int workingDays, double dailyWage) {
		super(name, age); 	// 调用父类构造方法
		this.workingDays = workingDays;  //初始化工作天数
		this.dailyWage = dailyWage;		//初始化日薪
		salary = this.workingDays*this.dailyWage;// 计算月薪， 月薪等于：工作天数 * 日薪
	}

	public void showInfo() { // 覆盖override父类的showInfo()方法
		System.out.println("【实习生】");
		super.showInfo(); // 调用父类的showInfo()，以显示姓名、年龄、月薪的信息
		System.out.println("工作天数：" + this.workingDays);
		System.out.println("日薪：" + this.dailyWage);
	}
}


public class TestExtend {

    public static void main(String[] args) {

    	Employee e1 = new Programmer("张三", 40, 10000, 2000);//创建程序员对象："张三", 40, 10000, 2000
    	e1.showInfo();
    	
    	Employee e2 = new Intern("李四", 18, 28, 100);//创建实习生对象："李四", 18, 28, 100
		e2.showInfo();
    }

}

编程题第三题

package step3;

abstract class Shape  { // 定义一个抽象类Shape，表示形状
	public double area; // 面积

	public abstract double getArea(); // 声明一个抽象方法 getArea()，方法的返回值类型是double
}

class Rectangle extends Shape { // 定义一个表示矩形的类Rectangle，继承Shape
	public double length; // 长
	public double width; // 宽

	public Rectangle(double length, double width) { // 构造方法
		this.length = length;
		this.width = width;
	}

	public double getArea() { // 实现父类的抽象方法 getArea()
		return length*width;  // 返回矩形的面积
	}
}

class Circle extends Shape { // 定义一个表示圆形的类Circle，继承Shape
	public double radius; // 半径

	public Circle(double radius){
        this.radius = radius;
    } // 定义Circle类的构造方法，初始化成员变量radius

	public double getArea() {
		return radius * radius * Math.PI;
	}
}

public class TestAbstract {
	public static void main(String[] args) {
		Shape s1 = new Rectangle(4,5); // 创建一个长为4，宽为5的Rectangle对象。
		System.out.println("此矩形的面积是：" + s1.getArea());
		Shape s2 = new Circle(3); // 创建一个半径为3的Circle对象。
		System.out.println("此圆形的面积是：" + s2.getArea()); // 打印出形状s2的面积
	}
}

编程题第四题

package step4;

public class Cat {
    String name;
    int weight ; // 重量
    public Cat(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }
	public String toString() {
        return this.name + "重" + this.weight + "公斤";
    }
    // Override 覆盖 Object 类的 equals 方法
    @Override
    public boolean equals(Object obj) {
        【补全代码】// 如果 obj 和 this 指向的是同一个对象，则返回 true
        【补全代码】// 如果 obj 指向的对象不是 Cat 类或其子类的对象，则返回 false
        Cat cat = 【补全代码】;  // 转换 obj 为 Cat 类型
        【补全代码】 // 如果 this 和 cat 这两只猫的名字和重量都是相等的，则返回 true，否则返回 false
    }
    // Override 覆盖 Object 类的 hashCode 方法
    @Override
    public int hashCode() {
        return 【补全代码】; // 要求能够根据猫的名字和重量计算 hashCode，相同名字和重量的猫的 hashCode 值相同
    }
    public static void main(String[] args) {
        Cat cat1 = new Cat("Tom", 20);
        Cat cat2 = new Cat("Tom", 20);
        System.out.println(【补全代码】); // 判断 cat1 和 cat2 是否指向同一对象
        System.out.println(【补全代码】); // 判断 cat1 和 cat2 是否 equals
        System.out.println(【补全代码】); // 判断 cat1 和 cat2 的hashCode值是否相等
    }
}

编程题第五题

package step5;

import java.util.Collections;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * 定义Product商品类，拥有成员变量pid、title、price，分别表示商品编号，商品名称，价格。
 * 覆写toString()函数。
 * 覆写compareTo()函数，当使用sort函数排序时，按商品价格从低到高排序。
 * 在main函数中，创建一个可以存放Product对象的ArrayList类型的list。
 * 创建3件商品，依次加入list中。
 * 排序前，使用增强型for循环遍历list，输出商品的信息。
 * 排序后，使用迭代器遍历list，输出商品的信息。
 */

class Product implements Comparable<Product>{
	private int pid ;		//商品编号
	private String title ;	//商品名称
	private int price ;		//价格
	
	public Product(int pid,String title,int price) {
		this.pid = pid ;
		this.title = title ;
		this.price = price ;
	}
	
	@Override
	【补全代码】{  //覆写toString()函数
		return "【商品信息】pid = " + this.pid + "、title = " + this.title + "、price = " + this.price ;
	}
	
	@Override
	public int compareTo(Product p) {
		【补全代码，不限行数】
	}
}


public class TestList {
    public static void main(String[] args) {
         
        Product proA = new Product(1,"小米手机",2999);
		Product proB = new Product(2,"摩托头盔",99);
		Product proC = new Product(3,"智能音箱",399);

		【补全代码完成如下要求，不限行数】
		//创建一个可以存放Product对象的ArrayList类型的容器list
		//依次将proA、proB、proC添加到list中

        
        System.out.println("排序前，使用增强型for循环遍历list：");
		【补全代码完成如下要求，不限行数】
        // 使用增强型for循环遍历list
       
		【补全代码完成如下要求】
		//使用Collections类的sort方法对list中的元素进行排序
		
        
        System.out.println("\n排序后，使用迭代器遍历list：");
        Iterator<Product> iterator = 【补全代码】; //获取list中的迭代器
        while (iterator.hasNext()) { 
        	【补全代码，不限行数】 
        }
    }
}

编程题第六题

package step6;

import java.util.Scanner;

public class StringTestNew {
	public static void main(String[] args) {
		//系统默认自动输入字符串"www.zsc.edu.cn"
		Scanner sc = new Scanner(System.in);
		String str = sc.next();
        
        //【请按以下要求补全代码】
		// 获取str第一个字符'.'的位置
		// 获取str最后一个字符'.'的位置
		// 获取str第一个字符'.'和最后一个字符'.'之间的子串sub，并输出
		// 将子串sub转换为大写，并输出
		// 关闭sc
	}
}