目录
1.方法重载
2.实例成员与类成员
3.static类成员
4.对象的组合
5. 对象的先上转型
6.引用类型（数组）参数传递
7.三角形类
8.机动车类补全代码
9.数组的引用与元素
10.求最大值
11.接口回调
12*.接口实现-Comparable
13.集体评分
14. 动物声音“模拟器
15.对象的上转型对象
16. 方法重写（计算立体图形的表面积和体积）
17.对象数组
18.程序改错（对象数组）
19. super关键字
20.方法重写（客车、皮卡车、货车）
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());
}
/* 此处输出图书总册数 */
}
}
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元
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;i<m.length;i++){
if(m[i]==0){
b1++;
}
if(m[i]>0){
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<n;i++){
a[i]= s.nextInt();
}
Function f=new Function();
f.func(a);
System.out.println("正数："+f.b2);
System.out.println("负数："+f.b3);
System.out.println("零："+f.b1);
}
}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<a.length;i++)
{
if(max<a[i])
{
max=a[i];
}
}
System.out.print("max="+max);
}
}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<count;i++){
aver+=x[i];
}
aver=aver/count;
return aver;
}
}
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};//班级某科目成绩
Gymnastics gymnastics=new Gymnastics();
School compurerAverage = new School();
//定义接口变量computer
double result = gymnastics.average(a); //变量computer实现接口回调计算体操选手平均分
System.out.printf("体操选手最后得分：%.2f\n", result);
double result1 = compurerAverage.average(b);//变量computer实现接口回调计算班级某科目平均分
System.out.printf("班级考试平均分数：%.2f\n", result1);
}
}
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]<grade[i+1]){
y=grade[i];
}
}
avg=(sum-s-y)/5;
return avg;
}
}
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<num;i++){//输入
person[i] = new Person(scanner.next(),scanner.nextInt());
}
String name = scanner.next();//需要检测的姓名
boolean flag = false;//该姓名是否已存在
int index=0;//标记对应的下标
for(int i=0;i<num;i++){//检测并输出信息
if(person[i].gettersName().equals(name)){//符合该姓名时
flag = true;
index = i;
}
System.out.println(person[i].toString());//输出信息
}
if(flag){
System.out.println("查询结果：");
System.out.println(person[index].toString());//输出信息
}
else{
System.out.println("查询结果：");
System.out.println("not found");
}
}
}
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;
}
}
