JAVA方向程序设计PTA期末考试小测试
目录
1.方法重载
2.实例成员与类成员
3.static类成员
4.对象的组合
5. 对象的先上转型
6.引用类型（数组）参数传递
7.三角形类
8.机动车类补全代码
9.数组的引用与元素
10.求最大值
11.接口回调
12*.接口实现-Comparable
13.集体评分
14. 动物声音“模拟器
15.对象的上转型对象
16. 方法重写（计算立体图形的表面积和体积）
17.对象数组
18.程序改错（对象数组）
19. super关键字
20.方法重写（客车、皮卡车、货车）
21.三角形三边异常的捕获
22.捕捉下标数组异常
23.接口实现与接口回调-Comparator
1.方法重载
根据题目要求完善代码。 一个木块如果高度比宽度大，我们说它是竖着放的，否则我们说它是平放的。 读入一个木块的高度和宽度。如果它是平放的，则输出A，否则输出B。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int height = in.nextInt();
int width = in.nextInt();
Board board = new Board(height, width);
char status = board.getStatus();
System.out.println(status);
}
}
class Board {
int height, width;
public Board(int height, int width) {
this.height = height;
this.width = width;
}
public char getStatus() {
if (height <= width) {
return 'A';
} else {
return 'B';
}
}
}
2.实例成员与类成员
程序模拟两个村庄共用同一口井水，Village类的变量waterAmount，用于模拟井水的水量。主类Land中创建两个村庄，一个村庄用水后改变了waterAmount的值，另一个村庄查看waterAmount的值。
class Village{
static int waterAmount=200; //定义waterAmount变量模拟水井的水量
String name; //村庄的名字
Village(String s) {
name = s;
}
void drinkWater(int n) {
waterAmount=waterAmount-n; //【代码2】 //水井水量减少n
System.out.println(name + "喝了" + n + "升水");
}
static int lookWaterAmount() {
return waterAmount;
}
}
public class Main{
public static void main(String args[]) {
//【代码3】 //设置水量waterAmount为200
int waterAmount=200;
int leftWater =waterAmount; //调用lookWaterAmount方法获取剩余水量
System.out.println("水井中有 " + leftWater + " 升水");
Village zhaoZhuang, liZhuang;
zhaoZhuang = new Village("赵庄");
liZhuang = new Village("李庄");
zhaoZhuang.drinkWater(50); //【代码5】//zhaoZhuang调用drinkWater方法喝水50
leftWater =liZhuang.lookWaterAmount();//【代码6】//liZhuang调用lookWaterAmount方法获取剩余水量
System.out.println(liZhuang.name + "发现水井中还有 " + leftWater + " 升水");
}
}
3.static类成员
声明一个图书类（Book），其四个属性分别为书号、书名、数量、图书总册数（静态数据成员）。
主类定义一个静态数据成员实现图书自动编号；main方法中定义对象数组，依次输入每种书的书名和数量，依次输出所有书的信息（书号、书名、数量）和图书总册数。
import java.util.Scanner;
class Book {
private int id; //书号
private String name; //书名
private int number; //数量static int num; //记录图书的总册数
Book(int id, String name, int number) {
this.id = id;
this.name = name;
this.number = number;}
public int getId() {
return id;
}public String getName() {
return name;
}public int getNumber() {
return number;
}
}public class Main {
static int id; //图书自动编号public static void main(String[] args) {
Scanner s = new Scanner(System.in);
Book book[] = new Book[5]; //对象数组/* 此处补充程序段录入图书信息 */
for (int i = 0; i < 5; i++) {
System.out.print("书号：" + book[i].getId() + "；");
System.out.print("书名：" + book[i].getName() + "；");
System.out.println("数量：" + book[i].getNumber());
}
/* 此处输出图书总册数 */
}
}
import java.util.Scanner;
class Book {
private int id; //书号
private String name; //书名
private int number; //数量
static int num; //记录图书的总册数
Book(int id, String name, int number) {
this.id = id;
this.name = name;
this.number = number;
num += number;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public int getNumber() {
return number;
}
}
public class Main {
static int id; //图书自动编号
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
Book book[] = new Book[5]; //对象数组
/* 此处补充程序段录入图书信息 */
for (int i = 0; i < 5; i++) {
System.out.print("请输入第" + (i + 1) + "本书的书名：");
String name = s.next();
System.out.print("请输入第" + (i + 1) + "本书的数量：");
int number = s.nextInt();
book[i] = new Book(id++, name, number);
}
/* 此处输出图书总册数 */
System.out.println("图书总册数：" + Book.num);
}
}
4.对象的组合
用类描述计算机中CPU的速度和硬盘的容量。要求Java应用程序有4个类，名字分别是PC，CPU和HardDisk和Main，其中Main是主类。
（1）PC类与CPU和HardDisk类关联的UML图
其中，CPU类要求getSpeed()返回speed的值；要求setSpeed(int m)方法将参数m的值赋值给speed。HardDisk类要求getAmount()返回amount的值，要求setAmount(int m)方法将参数m的值赋值给amount。PC类要求setCUP(CPU c) 将参数c的值赋值给cpu，要求setHardDisk (HardDisk h)方法将参数h的值赋值给HD，要求show()方法能显示cpu的速度和硬盘的容量。
（2）主类Main的要求
main方法中创建一个CPU对象cpu，cpu将自己的speed设置为2200，
main方法中创建一个HardDisk对象disk，disk将自己的amount设置为200，
main方法中创建一个PC对象pc，
pc调用setCUP(CPU c)方法，调用时实参是cpu，
pc调用setHardDisk (HardDisk h)方法，调用时实参是disk，
pc调用show()方法。
class CPU{
int speed;
void setSpeed(int m){
speed=m;
}
public int getSpeed(){
return speed;
}
}
class PC {
CPU cpu;
HardDisk HD;
public void setCPU(CPU c){
cpu=c;
}
public void setHardDisk(HardDisk h){
HD=h;
}
public void show() {
System.out.println("CPU速度："+cpu.getSpeed());
System.out.println("硬盘容量："+HD.getAmount());
}
}
class HardDisk {
int amount;
void setAmount(int m){
amount=m;
}
int getAmount(){
return amount;
}
}
public class Main{
public static void main(String[] args){
CPU cpu=new CPU();
cpu.speed=2200;
HardDisk disk=new HardDisk();
disk.amount=200;
PC pc=new PC();
pc.setCPU(cpu);
pc.setHardDisk(disk);
pc.show();
}
}5. 对象的先上转型
class Employee { //公司员工类
double earnings() { //计算年薪的方法
return 0;
}
}
class YearWorker extends Employee { //按年领薪水的员工
【代码1】 //重写earnings()方法，年薪200000
}
class MonthWorker extends Employee { //按月领薪水的员工
【代码2】 //重写earnings()方法，按月薪12000计算年薪，计12个月
}
class WeekWorker extends Employee { //按周领薪水的员工
【代码3】 //重写earnings()方法，按周薪3500计算年薪，计52周
}
class Company {
Employee[] employee;
Company(Employee[] e) {
employee = e;
}
double salariesPay() {
double salaries = 0;
【代码4】 //计算所有员工的总年薪
return salaries;
}
}
public class CompanySalary {
public static void main(String args[]) {
Employee [] e = new Employee[23]; //声明公司有23名雇员
double sum = 0;
【代码5】 //创建10名年薪制雇员（0~9号），并计算他们的年薪总支出
System.out.println("年薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
【代码6】 //创建8名月薪制雇员（10~17号），并计算他们的年薪总支出
System.out.println("月薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
【代码7】 //创建5名按周计薪雇员（18~22号），并计算他们的年薪总支出
System.out.println("按周计薪雇员的薪水总支出:" + sum + "元");
Company company = new Company(e);
System.out.println("本年度公司薪水总支出:" + company.salariesPay() + "元");
}
}输出
年薪制雇员的薪水总支出:2000000.0元
月薪制雇员的薪水总支出:1152000.0元
按周计薪雇员的薪水总支出:910000.0元
本年度公司薪水总支出:4062000.0元
class Employee { //公司员工类
double earnings() { //计算年薪的方法
return 0;
}
}
class YearWorker extends Employee { //按年领薪水的员工
double earnings() { //重写earnings()方法，年薪200000
return 200000;
}
}
class MonthWorker extends Employee { //按月领薪水的员工
double earnings() { //重写earnings()方法，按月薪12000计算年薪，计12个月
return 12000 * 12;
}
}
class WeekWorker extends Employee { //按周领薪水的员工
double earnings() { //重写earnings()方法，按周薪3500计算年薪，计52周
return 3500 * 52;
}
}
class Company {
Employee[] employee;
Company(Employee[] e) {
employee = e;
}
double salariesPay() {
double salaries = 0;
for (int i = 0; i < employee.length; i++) {
salaries += employee[i].earnings();
}
return salaries;
}
}
public class CompanySalary {
public static void main(String args[]) {
Employee [] e = new Employee[23]; //声明公司有23名雇员
double sum = 0;
for (int i = 0; i < 10; i++) { //创建10名年薪制雇员（09号），并计算他们的年薪总支出
e[i] = new YearWorker();
sum += e[i].earnings();
}
System.out.println("年薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
for (int i = 10; i < 18; i++) { //创建8名月薪制雇员（1017号），并计算他们的年薪总支出
e[i] = new MonthWorker();
sum += e[i].earnings();
}
System.out.println("月薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
for (int i = 18; i < 23; i++) { //创建5名按周计薪雇员（18~22号），并计算他们的年薪总支出
e[i] = new WeekWorker();
sum += e[i].earnings();
}
System.out.println("按周计薪雇员的薪水总支出:" + sum + "元");
Company company = new Company(e);
System.out.println("本年度公司薪水总支出:" + company.salariesPay() + "元");
}
}6.引用类型（数组）参数传递
在主类main方法中输入若干个数据存储在数组中，Function类中编写方法计算这些数据中正数、负数和0的个数。在主类main方法中调用该方法输出结果。
import java.util.Scanner;
class Function{
int b1;
int b2;
int b3;
void func(int m[]){
int b1 = 0;
int b2 = 0;
int b3 = 0;
for(int i=0;i0){
b2++;
}
if(m[i]<0){
b3++;
}
}
this.b1=b1;
this.b2=b2;
this.b3=b3;
}
}
public class Main{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int a[] = new int[n];
for(int i=0;i 7.三角形类
（1）定义一个三角形类，类中定义三角形的底和高属性；定义一个构造方法，通过参数分别给底和高属性传值；定义一个计算三角形面积的方法，并返回计算结果；
（2）在主类中生成一个底和高分别是12和5的三角形，计算它的面积；然后修改它的底为20，重新计算面积。
public class Main{
public static void main(String args[]) {
sanjiao s1 = new sanjiao();
s1.setGao(12);
s1.setChang(5);
double s=(s1.chang*s1.gao)/2;
System.out.println("三角形的面积为："+s);
s1.changegao(20);
double cs=(s1.chang*s1.gao)/2;
System.out.print("修改后三角形的面积为："+cs);
}
}
class sanjiao{
double chang;
double gao;
public double getChang() {
return chang;
}
public void setChang(double chang) {
this.chang = chang;
}
public double getGao() {
return gao;
}
public void setGao(double gao) {
this.gao = gao;
}
void changegao(double d){
gao=d;
}
}8.机动车类补全代码
class Vehicle {
double speed;
int power;
void speedUp(int s) {
speed += s;
}
void speedDown(int d) {
speed -= d;
}
void setPower(int p) {
power = p;
}
int getPower() {
return power;
}
void setSpeed(int s){
speed=s;
}
double getSpeed() {
return speed;
}
}
public class Main{
public static void main(String args[]) {
Vehicle car1=new Vehicle();
Vehicle car2=new Vehicle();
car1.setPower(128);
car2.setPower(76);
System.out.println("car1的功率是：" + car1.getPower());
System.out.println("car2的功率是：" + car2.getPower());
car1.setSpeed(80);
car2.setSpeed(100);
System.out.println("car1目前的速度：" + car1.getSpeed());
System.out.println("car2目前的速度：" + car2.getSpeed());
car1.speedDown(10);
car2.speedDown(20);
System.out.println("car1目前的速度：" + car1.getSpeed());
System.out.print("car2目前的速度：" + car2.getSpeed());
}
}
9.数组的引用与元素
public class Main {
public static void main (String args[ ]) {
int [] a = {100, 200, 300};
【代码1】// 输出数组a的长度
【代码2】// 声明一个5行5列的二维数组b
【代码3】// 输出二维数组b的一维数组的个数
System.out.println(b[4][2]);
【代码4】//将数组a的引用赋给b[4]
System.out.println(b[4][2]);
}
}
public class Main {
public static void main (String args[ ]) {
int [] a = {100, 200, 300};
System.out.println("数组a的长度："+a.length);
int b[][] = {{1}, {1,1}, {1,2,1}, {1,3,3,1}, {1,4,0,4,1}};
System.out.println("二维数组b中一维数组的个数："+b.length);
System.out.println(b[4][2]);
b[4]=a;
System.out.print(b[4][2]);
}
}
10.求最大值
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[]=new int[10];
int max=a[0];
Scanner sc=new Scanner(System.in);
for(int i=0;i<10;i++)
{
//System.out.println("输入"+(i+1)+"个整数");
a[i]=sc.nextInt();
}
for(int i=1;i 11.接口回调
体操类（Gymnastics）计算选手平均分是去掉一个最高分和最低分后再计算平均分，
学校类（School）计算一个班级某门课的平均分是计算算术平均，
体操类和学校类都实现了CompurerAverage接口。
补充代码：
interface CompurerAverage {
public double average(double x[]);
}
class Gymnastics implements CompurerAverage {
public double average(double x[]) {
int count = x.length;
double aver = 0, temp;
for (int j = 1; j < count; j++) { //进行升序排列
for (int i = 0; i < count - i; i++) {
if (x[i] > x[i + 1]) {
temp = x[i];
x[i] = x[i + 1];
x[i + 1] = temp;
}
}
}
for (int i = 1; i < count - 1; i++) { //排除第一个和最后一个求和
aver = aver + x[i];
}
return aver / (count - 2);
}
}
class School implements CompurerAverage {
@Override
public double average(double[] x) {
int count=x.length;
double aver=0;
for(int i=0;i
12*.接口实现-Comparable
编写实现Comparable接口的PersonSortable类，使其按name以及age排序。
1、编写PersonSortable类
属性：private name(String)、private age(int)
有参构造方法：参数为name，age
toString方法：返回格式为：name-age
实现Comparable接口：实现先对name升序排序，如果name相同则对age进行升序排序
2、main方法中
首先输入n；
输入n行name和age，并创建n个对象放入数组；
使用Arrays.sort()方法对数组进行排序后输出。
Arrays.sort(Object[] a)：
对于基本数据类型、String类型数组可直接排序，因为这些类型中自带了compareTo()方法；
对于自定义类型，则需要让该类实现Comparable接口，重写其中的compareTo()方法。
（a.compareTo(b)：返回一个整数值，如果a>b，返回正整数，反之，返回负整数；相等则返回0。）
interface CompurerAverage {
public double average(double x[]);
}
class Gymnastics implements CompurerAverage {
public double average(double x[]) {
int count = x.length;
double aver = 0, temp;
for (int j = 1; j < count; j++) { //进行升序排列
for (int i = 0; i < count - i; i++) {
if (x[i] > x[i + 1]) {
temp = x[i];
x[i] = x[i + 1];
x[i + 1] = temp;
}
}
}
for (int i = 1; i < count - 1; i++) { //排除第一个和最后一个求和
aver = aver + x[i];
}
return aver / (count - 2);
}
}
class School implements CompurerAverage {
@Override
public double average(double[] x) {
return 0;
}
}
public class Main{
public static void main(String args[]) {
double a[] = {9.89, 9.88, 9.99, 9.12, 9.69, 9.76, 8.97};//体操选手成绩
double b[] = {89, 56, 78, 90, 100, 77, 56, 45, 36, 79, 98};//班级某科目成绩
CompurerAverage compurerAverage = new School();
//定义接口变量computer
double result = compurerAverage.average(a); //变量computer实现接口回调计算体操选手平均分
System.out.printf("体操选手最后得分：%.2f\n", result);
//变量computer实现接口回调计算班级某科目平均分
System.out.printf("班级考试平均分数：%.2f\n", result);
}
}
13.集体评分
请补充以下代码，完成题目要求（原程序语句不做修改删减）：
有一个团队由n个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的分数的平均分就是该团队对指导老师的评分。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] grade = new int[n];
for (int i = 0; i < n; i++) {
grade[i] = in.nextInt();
}
RR rr = new RT(grade);
System.out.printf("%.2f", rr.mark());
}
}
abstract class RR {
int[] grade;
public RR(int[] grade) {
this.grade = grade;
}
public abstract double mark();
}
class RT extends RR {
}
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] grade = new int[n];
for (int i = 0; i < n; i++) {
grade[i] = in.nextInt();
}
RR rr = new RT(grade);
System.out.printf("%.2f", rr.mark());
}
}
abstract class RR{
int[] grade;
public RR(int[] grade) {
this.grade = grade;
}
public abstract double mark();
}
class RT extends RR{
public RT(int[] grade) {
super(grade);
}
@Override
public double mark() {
double avg=0;
double sum=0;
for (int i=0;i<5;i++){
sum=sum+grade[i];
}
double s=0,y = 0;
for (int i = 0; i < 5; i++) {
if(grade[i]>grade[i+1]){
s=grade[i];
}
}
for (int i = 0; i < 5; i++) {
if(grade[i]
14. 动物声音“模拟器
设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声。要求如下：
（1）编写抽象类Animal
Animal抽象类有2个抽象方法cry()和getAnimaName()，即要求各种具体的动物给出自己的叫声和种类名称。
（2）编写模拟器类Simulator
该类有一个playSound(Animal animal)方法。参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音、调用子类重写的getAnimalName()方法显示动物种类的名称。
（3）编写Animal类的子类：Dog，Cat类
（4）编写主类
在主类的main方法中包含如下代码：
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
abstract class Animal{
abstract void cry();
abstract void getAnimaName();
}
class Dog extends Animal{
void cry() {
System.out.println("现在播放狗的声音："+"汪汪...汪汪");
}
void getAnimaName() {
System.out.println("狗狗");
}
}
class Cat extends Animal{
void cry() {
System.out.println("现在播放猫的声音："+"喵喵...喵喵");
}
void getAnimaName() {
System.out.println("猫猫");
}
}
class Simulator{
void playSound(Animal animal) {
animal.cry();
}
}
public class Main{
public static void main(String args[]) {
Simulator simulator=new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
}
}
15.对象的上转型对象
补充程序：
class Employee { //公司员工类
double earnings() { //计算年薪的方法
return 0;
}
}
class YearWorker extends Employee { //按年领薪水的员工
【代码1】 //重写earnings()方法，年薪200000
}
class MonthWorker extends Employee { //按月领薪水的员工
【代码2】 //重写earnings()方法，按月薪12000计算年薪，计12个月
}
class WeekWorker extends Employee { //按周领薪水的员工
【代码3】 //重写earnings()方法，按周薪3500计算年薪，计52周
}
class Company {
Employee[] employee;
Company(Employee[] e) {
employee = e;
}
double salariesPay() {
double salaries = 0;
【代码4】 //计算所有员工的总年薪
return salaries;
}
}
public class CompanySalary {
public static void main(String args[]) {
Employee [] e = new Employee[23]; //声明公司有23名雇员
double sum = 0;
【代码5】 //创建10名年薪制雇员（0~9号），并计算他们的年薪总支出
System.out.println("年薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
【代码6】 //创建8名月薪制雇员（10~17号），并计算他们的年薪总支出
System.out.println("月薪制雇员的薪水总支出:" + sum + "元");
sum = 0;
【代码7】 //创建5名按周计薪雇员（18~22号），并计算他们的年薪总支出
System.out.println("按周计薪雇员的薪水总支出:" + sum + "元");
Company company = new Company(e);
System.out.println("本年度公司薪水总支出:" + company.salariesPay() + "元");
}
}
输入格式:
无需输入。
输出格式:
与样例一致。
输入样例:
输出样例:
年薪制雇员的薪水总支出:2000000.0元
月薪制雇员的薪水总支出:1152000.0元
按周计薪雇员的薪水总支出:910000.0元
本年度公司薪水总支出:4062000.0元
16. 方法重写（计算立体图形的表面积和体积）
计算如下立体图形的表面积和体积：
从图中观察，可抽取长方体和四棱锥两种立体图形的共同属性到父类Rect中：长度：l 宽度：h 高度：z。
要求：
（1）在父类Rect中，定义求底面积的方法area( )。
（2）定义父类Rect的子类立方体类Cubic，计算立方体的表面积和体积。其中表面积area( )重写父类的方法。
（3）定义父类Rect的子类四棱锥类Pyramid，计算四棱锥的表面积和体积。其中表面积area( )重写父类的方法。
（4）在主类中，输入立体图形的长(l)、宽(h)、高(z)数据，分别输出长方体的表面积、体积、四棱锥的表面积和体积。
提示：
四棱锥表面积公式：
四棱锥体积公式：V= Sh/3，S——底面积，h——高
输入格式:
输入三个数值，分别表示l、h、z，数值之间用空格分隔。
若输入数据中有0或负数，则不表示任何图形，表面积和体积均为0。
输出格式:
输出数值为长方体表面积、长方体体积、四棱锥表面积、四棱锥体积（中间有一个空格作为间隔，数值保留两位小数）。
输入样例1:
1 2 3
输出样例1:
22.00 6.00 11.25 2.00
输入样例2:
0 2 3
输出样例2:
0.00 0.00 0.00 0.00
输入样例3:
-1 2 3
输出样例3:
0.00 0.00 0.00 0.00
import java.util.Scanner;
abstract class Rect{
double l;
double h;
double z;
Rect(double l, double h, double z){
this.l = l;
this.h = h;
this.z = z;
if(l <= 0 || h <= 0 || z <= 0){
this.h = this.l = this.z = 0;
}
}
double length(){
return l * h;
}
abstract double area();
}
class Cubic extends Rect{
Cubic(double l, double h, double z){
super(l, h, z);
}
@Override
double area() {
return 2 * (l * h + h * z + l * z);
}
double V(){
return l * h * z;
}
}
class Pyramid extends Rect{
Pyramid(double l, double h, double z){
super(l, h, z);
}
@Override
double area() {
return l * h + (h * Math.sqrt((l / 2) * (l / 2) + z * z)) + (l * Math.sqrt((h / 2) * (h / 2) + z * z));
}
double V(){
return l * h * z / 3;
}
}
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
double l = sc.nextDouble();
double h = sc.nextDouble();
double z = sc.nextDouble();
Cubic c = new Cubic(l, h, z);
Pyramid p = new Pyramid(l, h, z);
System.out.printf("%.2f %.2f %.2f %.2f\n", c.area(), c.V(), p.area(), p.V());
}
}
}
17.对象数组
有一个人员数组，要在此数组中查询某个人是否存在，具体要求如下：
1、定义Person类：
a、私有属性 name和age
b、两个属性的getters 和setters
c、带参数构造方法，为name和age传值
d、ToString方法
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
2、在主类main方法中创建Person数组，数组长度通过键盘输入，数组每一个对象的name和age通过键盘输入；创建数组后，首先显示所有人员的信息，然后输入一个姓名，查询数组中是否有这个人，如果有则输出这个人的信息，否则输出not found。
输入格式:
第一行输入数组长度n；
从第二行开始依次输入每个人的姓名和年龄；
最后一行输入要查询的人的姓名。
输出格式:
与样例一致。
输入样例1:
3
tian 21
jerry 23
sun 22
su
输出样例1:
Person [name=tian, age=21]
Person [name=jerry, age=23]
Person [name=sun, age=22]
查询结果：
not found
输入样例2:
3
may 51
sunny 23
lily 32
lily
输出样例2:
Person [name=may, age=51]
Person [name=sunny, age=23]
Person [name=lily, age=32]
查询结果：
Person [name=lily, age=32]
输入样例3:
4
lily 51
Emily 30
sunny 23
lily 32
lily
输出样例3:
Person [name=lily, age=51]
Person [name=Emily, age=30]
Person [name=sunny, age=23]
Person [name=lily, age=32]
查询结果：
Person [name=lily, age=51]
Person [name=lily, age=32]
import java.util.Scanner;
class Person{
private String name;
private int age;
public String gettersName(){
return name;
}
public void settersName(String name){
this.name=name;
}
public int gettersAge(){
return age;
}
public void settersAge(int age){
this.age=age;
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public Person(){
this.name="none";
this.age=1;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();//数组长度
Person person[] = new Person[num];
for(int i=0;i
18.程序改错（对象数组）
修改如下程序的语法错误和逻辑错误，使程序运行结果。
public class Student {
private String name;
private double score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public void toString() {
return this.name + "--" + this.score;
}
}
public class Main {
public static void main(String args[]) {
String[] name = {"Tom", "Jim", "Apple", "Rose", "Jack", "Lucy"};
double[] score = {98, 76, 85, 66, 72};
Student[] sGroup = new Student[name.length];
for (int i = 0; i < sGroup.length; i++)
sGroup[i] = new Student(name[i], score[i]);
System.out.println("Student");
for (int i = 0; i < sGroup.length; i++)
System.out.println(sGroup[i]);
System.out.println("end");
}
}
输入格式:
无需输入。
输出格式:
与样例一致。
输入样例:
输出样例:
class Student {
private String name;
private double score;
public Student(String name, double score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String toString() {
return this.name + "--" + this.score;
}
}
public class Main{
public static void main(String[] args) {
String[] name = {"Tom", "Jim", "Apple", "Rose", "Jack", "Lucy"};
double[] score = {98, 76, 85, 66, 72,80};
Student[] sGroup = new Student[name.length];
for (int i = 0; i < sGroup.length; i++)
sGroup[i] = new Student(name[i],score[i]);
System.out.println("Student");
for (int i = 0; i < sGroup.length; i++)
System.out.println(sGroup[i]);
System.out.println("end");
}
}
Student
Tom--98.0
Jim--76.0
Apple--85.0
Rose--66.0
Jack--72.0
Lucy--80.0
end
19. super关键字
建设银行ConstructionBank是Bank的子类，
ConstructionBank重写计算利息的方法computerInterest()，
ConstructionBank自己声明了一个double型的year变量。
例如：当year取值为5.116时，表示存款时长为5年零116天
ConstructionBank先按Bank的方法computerInterest()计算出5年的利息，
再自己计算116天的利息。
import java.util.Scanner;
class Bank {
int savedMoney; //存款金额
int year; //整年数
private double interestRate; //年利率
Bank(double rate) {
interestRate = rate;
}
double computerInterest() { //计算整年的利息
return year * interestRate * savedMoney;
}
}
class ConstructionBank extends Bank {
double year;
ConstructionBank(double rate, double year) {
【代码1】 //调用Bank的构造方法设置年利率
this.year = year;
}
double computerInterest() {
【代码2】 //整年数赋值给Bank的year属性
int day = (int)((year - (int)year) * 1000); //计算零散的天数
double yearInterest = 【代码3】 //调用Bank中的computerInterest()方法计算整年的利息
double dayInterest = day * 0.0001 * savedMoney; //按天利率0.0001计算零散天数的利息
return yearInterest + dayInterest;
}
}
public class Main {
public static void main(String args[]) {
Scanner reader = new Scanner(System.in);
double a = reader.nextDouble(); //输入存款时长8.236
int b = reader.nextInt(); //输入存款金额8000
【代码4】 //创建建设银行的bank1对象，设置年利率为0.035，存款时长为a
【代码5】 //设置存款金额为b
System.out.println("利息为：" + bank1.computerInterest());
}
}
输入格式:
输入两个数，分别表示存款时长和存款金额，中间空格隔开。
输出格式:
显示“利息为：XXX”
输入样例:
8.236 8000
输出样例:
在这里给出相应的输出。例如：
利息为：2428.8
import java.util.Scanner;
class Bank{
int savedMoney; //存款金额
int year; //整年数
private double interestRate; //年利率
Bank(double rate){
interestRate=rate;
}
double computerInterest(){ //计算整年的利息
return year * interestRate * savedMoney;
}
}
class ConstructionBank extends Bank{
double year;
ConstructionBank(double rate,double year){
super(rate);
this.year=year;
}
double computerInterest(){
super.year=(int)year; //整年数赋值给Bank的year属性
int day = (int)((year - (int)year) * 1000); //计算零散的天数
double yearInterest =super.computerInterest(); //调用Bank中的computerInterest()方法计算整年的利息
double dayInterest = day * 0.0001 * savedMoney; //按天利率0.0001计算零散天数的利息
return yearInterest + dayInterest;
}
}
public class Main{
public static void main(String args[]){
Scanner reader = new Scanner(System.in);
double a =reader.nextDouble(); //输入存款时长8.236
int b =reader.nextInt(); //输入存款金额8000
ConstructionBank bank1=new ConstructionBank(0.035,a); //创建建设银行的bank1对象，设置年利率为0.035，存款时长为a
bank1.savedMoney=8000; //设置存款金额为b
System.out.println("利息为：" + bank1.computerInterest());
}
}
20.方法重写（客车、皮卡车、货车）
请充分利用面向对象思想，为公司解决租车问题，根据客户选定的车型和租车天数，计算载客总人数，载货总重量，租车总费用。
公司现有三种车型（客车、皮卡车、货车），每种车都有编号（名称）和租金单价的属性；
其中：客车只能载人，货车只能载货，皮卡车是客货两用车，即可以载人，也可以载货。
下面是租车公司的可用车型、容量及价目表：
要求：根据客户输入的所租车型的序号及天数，计算所能乘载的总人数、货物总重量及租车费用总金额。
目前已定义三种车型的父类Vehicle，请以此基础完成代码实现功能。
class Vehicle {
int id; //编号
int price; //单价
static int sum; //总人数
static double weight;//总重量
static int totol; //总金额
void computeSum() {
}
void computeWeight() {
}
void computeTotal() {
}
}
输入格式:
首行输入一个整数，代表要租车的数量N；
接下来是N行数据，每行2个整数m和n，其中：m表示要租车的编号，n表示租用该车型的天数。
输出格式:
输出一行数据，数据间有一个空格，含义为：
载客总人数 载货总重量（保留2位小数） 租车金额（整数）
输入样例1:
2
1 1
2 2
输出样例1:
15 0.00 1600
输入样例2:
3
3 1
6 2
10 3
输出样例2:
15 105.90 7800
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
if(a == 0) {
System.out.println("0 0.00 0");
} else if (a == 1) {
int N = in.nextInt();
int n_people = 0;
double n_goods = 0;
int n_money = 0;
while(N > 0) {
int m = in.nextInt();
int n = in.nextInt();
Car car = new Car();
car.choose(m,car);
n_people = car.n_person * n + n_people;
n_goods = car.n_goods * n + n_goods;
n_money = car.money * n + n_money;
N --;
}
System.out.printf("%d %.2f %d",n_people,n_goods,n_money);
}
}
}
class Car {
public int n_person;
public double n_goods;
public int money;
private Car car(int i, double v, int i1) {
this.n_person = i;
this.n_goods = v;
this.money = i1;
return null;
}
public Car choose(int m, Car car) {
if(m == 1) {
return car(5,0.0,800);
} else if(m == 2) {
return car(5,0.0,400);
} else if(m == 3) {
return car(5,0.0,800);
} else if(m == 4) {
return car(51,0.0,1300);
} else if(m == 5) {
return car(55,0.0,1500);
} else if(m == 6) {
return car(5,0.45,500);
} else if(m == 7) {
return car(5,2.0,450);
} else if(m == 8) {
return car(0,3.0,200);
} else if(m == 9) {
return car(0,25,1500);
} else if(m == 10) {
return car(0,35.0,2000);
}
return car;
}
}
21.三角形三边异常的捕获
创建一个IllegalTriangleException类，处理三角形的三边，任意两边之和小于等于第三边，则显示三条边不符合要求。
设计一个有三条边的Triangle的类。如果三条边不符合要求，则抛出一个IllegalTriangleException异常。
三角形的构造方法如下：
public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
//实现
}
三角形类中toString()的方法返回这个三角形的字符串描述，toString()方法的实现如下所示：
return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
主类如下：
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double s1 = input.nextDouble();
double s2 = input.nextDouble();
double s3 = input.nextDouble();
try {
Triangle t = new Triangle(s1, s2, s3);
System.out.println(t.toString());
} catch (IllegalTriangleException ex) {
System.out.println(ex.getMessage());
}
}
}
输入格式:
输入三个数据表示三条边。
输出格式:
与样例一致。
输入样例1:
1 1 1
输出样例1:
Triangle [side1=1.0, side2=1.0, side3=1.0]
输入样例2:
1 2 3
输出样例2:
Invalid: 1.0,2.0,3.0
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double s1 = input.nextDouble();
double s2 = input.nextDouble();
double s3 = input.nextDouble();
try {
Triangle t = new Triangle(s1,s2,s3);
System.out.println(t);
}
catch (IllegalTriangleException ex) {
System.out.println(ex.getMessage());
}
}
}
//创建一个IllegalTriangleException类，处理三角形的三边，任意两边之和小于等于第三边，则显示三条边不符合要求
class IllegalTriangleException extends Exception{
public IllegalTriangleException(String message) {
super(message);
}
}
//然后设计一个有三条边的Triangle的类。如果三条边不符合要求，则抛出一个IllegalTriangleException异常。
class Triangle{
double side1;
double side2;
double side3;
public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
this.side1=side1;
this.side2=side2;
this.side3=side3;
if(this.side1+this.side2<=this.side3||this.side2+this.side3<=this.side1||this.side1+this.side3<=this.side2)
{
throw new IllegalTriangleException("Invalid: "+this.side1+","+this.side2+","+this.side3);
}
}
public String toString() {
return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
}
}
22.捕捉下标数组异常
main方法：
事先定义好一个大小为5的数组。
根据屏幕输入产生相应异常。
提示：可以使用System.out.println(e)打印异常对象的信息，其中e为捕获到的异常对象。
输入格式:
arr 代表访问数组，然后输入下标，如果抛出ArrayIndexOutOfBoundsException异常则显示，如果不抛出异常则显示下标。
other，结束程序。
输出格式:
与样例一致。
输入样例:
arr 3
arr 9
arr 2
arr 10
other
输出样例:
下标：3
java.lang.ArrayIndexOutOfBoundsException: Index 9 out of bounds for length 5
下标：2
java.lang.ArrayIndexOutOfBoundsException: Index 10 out o
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int []arr = new int [5];
Scanner input = new Scanner(System.in);
int i=1;
while (input.hasNext()){
i++;
String a = input.next();
if (a.equals("arr")){
int b = input.nextInt();
try {
int d = arr[b];
}catch (Exception e){
System.out.println("下标："+i);
System.out.println(e.toString());
}
}else if (a.equals("num")){
String b = input.next();
try{
int d = Integer.parseInt(b);
}catch (Exception e){
System.out.println("下标："+i);
System.out.println(e.toString());
}
}else if (a.equals("cast")){
try {
Object str = new String("cc");
System.out.println((Integer)(str));
}catch (Exception e){
System.out.println("下标："+i);
System.out.println(e.toString());
}
}else if (a.equals("null")){
try {
String t = null;
int l = t.length();
}catch (Exception e){
System.out.println("下标："+i);
System.out.println(e.toString());
}
}else {
System.exit(0);
}
}
}
}
23.接口实现与接口回调-Comparator
Arrays.sort()可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，例如：有时需要对name进行降序排序，有时需要对年龄进行升序排序，使用Comparable就无法满足这样的需求。可以编写不同的Comparator接口类来满足多样的排序需求。
1、编写PersonSortable2类
属性：private name(String)、private age(int)
有参构造函数：参数为name，age
toString方法：返回格式为：name-age
2、编写Comparator接口类
编写NameComparator类，实现对name进行降序排序；
编写AgeComparator类，对age进行升序排序。
根据升降序需求重写compare(a,b)方法。
（compare(a,b)：返回一个整数值，如果a>b，返回正整数，反之，返回负整数；相等则返回0。）
3、main方法中
首先输入n；
输入n行name和age，并创建n个对象放入数组；
使用Arrays.sort()方法对数组进行排序后输出：
（1）对数组按照name进行降序排序后输出；
（2）在此基础上对数组按照age进行升序排序后输出。
Arrays.sort(T[] a, Comparator c)：接口回调，调用已经封装好的排序规则进行排序。
输入格式:
第一行输入人数；
第二行开始依次输入每个人的姓名和年龄，空格隔开。
输出格式:
与样例一致。
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17
输出样例:
NameComparator:sort
zhang-15
zhang-12
wang-14
li-17
Wang-17
AgeComparator:sort
zhang-12
wang-14
zhang-15
li-17
Wang-17