恒定橡果的java习题八

1.骑电瓶车游览景点

【问题描述】编写一个java应用程序，模拟骑电瓶车游览景区10个景点中任意4个以上的景点，景点名称为0，1，2...7，8，9。景点与景点之间的距离可以用下图

表示，电瓶车电池初始电量为100个单位，每一公里消耗电量10个单位，当预计无法到达下一个景点时就需要在当前景点更换电池，更换后电池保持满的

状态。具体要求如下：

1、分别创建电池、电瓶车、地图、以及主类Visit。

2、接受输入需要游览的景点名称，输入字符表示结束。

3、输出游览过程中的行为，如例子所示。

各景点里程图

           0        1       2        3        4        5       6       7       8

1       2.3

2       4.6      3.4

3       5.6      4.5     5.1

4       4.8      3.7     6.1     3.5

5       3.8      3.1     4.3     1.5     3.2

6       4.8      4.2     5.3     3.3     3.7      2.4

7       3.8      4.1     6.3     3.9     1.9      3.3      6.4

8       5.8      7.1     5.5     3.4     4.2      5.4      5.6     4.5

9      4.8      6.1     2.3     3.4     3.7      4.4      6.6     3.7       4.2
【输入形式】

     输入字符，每行一个景点，最后一个非景点字符。

【输出形式】

游览过程行为，包括：

1、Visit【景点】

2、Change battery at【景点】

3、From【景点】to【景点】battery consume 【电量】 remain 【电量】

每个动作单独一行输出。
【样例输入】

0

1

2

3

A

【样例输出】

Visit 0

From 0 to 1 battery consume 23 remain 77

Visit 1

From 1 to 2 battery consume 34 remain 43

Visit 2

Change battery at 2

From 2 to 3 battery consume 51 remain 49

Visit 3
【样例说明】

如果输入的合法景点少于四个，显示输入错误信息：

Please input number >= 4

并退出程序

public class main {
    public static void main(String[] args) {
        int [] positionArray=new int[10];//设置一个能存放11个数的数组（可以根据输入需求更改不得少于4就行）
        Scanner scanner = new Scanner(System.in);
        int number=0;
        while(scanner.hasNextInt()&& number<10){
            positionArray[number++]=scanner.nextInt();
        }//如果输入的是整数，且number小于10，那么把数放入数组中，number+1
        if(number<4){
            System.out.println("number should be big than 4");}//如果输入的数少于4个那么输出指定信息
        ElectricityCar myCar=new ElectricityCar(positionArray[0]);//创建一个新的Car类
        for (int i=0;i<number-1;i++){
            myCar.drive(positionArray[i],positionArray[i+1]);//调用drive方式输出
            if(i==number-2){
                System.out.println("Visit"+positionArray[i+1]);
            }//如果是最后一个数，那么额外输出一次代表在最后一个景点停留，展示最后一个景点
        }

    }
}
class ElectricityCar{//定义电车类
    private Map mymap=new Map();//创建一个新的Map类（地图类）
    Battery myBattery=new Battery();//创建一个新的Battery类（电池类）
    int position;
    private void visit(int to){
        System.out.println("Visit"+to);
    }//输出当前景点位置
    ElectricityCar(int position){
        this.position=position;
    }//更新景点
    void drive(int from, int to) {
        if (from > 9 || to < 0){
            return;}//如果输入的数不在景点范围内，那么直接退出
        new ElectricityCar(from);//更新景点位置，确定出发点在哪
        visit(from);//输出景点位置
        double distance = mymap.getDistance(position, to);//计算出发点到新景点之间的距离
        if (!myBattery.consume(distance * 10)) {
            changeBattery();//重置电瓶电量
            myBattery.consume(distance * 10);//计算剩余电量
            System.out.println("Change battery at "+from);//输出信息，在该景点更换电瓶
        }
        System.out.printf("From %d to %d battery consume %d remain %d",from,to,(int)(distance*10),(int)myBattery.getVolume());
        System.out.println();
    }
    private void changeBattery(){
        myBattery=new Battery();
    }//更新电量，重置为设定值

}
class Battery{//定义电瓶类
    private double volume=100;//剩余电量初始值为100
    boolean consume(double consummVolume){
        if(consummVolume<=volume){//如果使用电量小于剩余电量
            volume-=consummVolume;//更新剩余电量
            return true;
        }else
            return false;
    }
    double getVolume(){
        return volume;
    }//输出剩余电量
}
class Map{//定义地图类
    private double map[][]={
            {0},
            {2.3},
            {4.6, 3.4},
            {5.6, 4.5, 5.1},
            {4.8, 3.7, 6.1, 3.5},
            {3.8, 3.1, 4.3, 1.5, 3.2},
            {4.8, 4.2, 5.3, 3.3, 3.7, 2.4},
            {3.8, 4.1, 6.3, 3.9, 1.9, 3.3, 6.4},
            {5.8, 7.1, 5.5, 3.4, 4.2, 5.4, 5.6, 4.5},
            {4.8, 6.1, 2.3, 3.4, 3.7, 4.4, 6.6, 3.7, 4.2}
    };//定义二维数组
    double getDistance(int from,int to){
        if(from==to)
            return 0;
        int max=from>to?from:to;
        int min=from<to?from:to;
        return map[max][min];
    }//根据输入，输出对应的景点距离
}

定义了三个类，电车类，电瓶类，地图类，在电车类里调用了另外两个类，然后计算。看起来很复杂实际上理清楚思路不难的。代码中注释基本上都加了，就不过多解释了。

2.汽车租赁公司经营额

【问题描述】要求模拟汽车租赁公司经营情况，公司有30辆轿车，租赁以天为单位，每天180元，大客车10辆，租赁以里程为单位，每百公里500元，平均每个月行驶8000公里，公司还有货运汽车5辆，租赁费用以公里数和吨数计算，3.5元每吨一公里，平均每周可以运载货物30000吨公里。

要求有一个父类，名为rentCar。子类有Taxi,Bus,Truck，父类rentCar具有earnMoney方法。

有一个Company类，用rentCar对象数组表示公司的可用车辆。程序能输出Company对象指定年份（2000～2020年）的营业额（万元）。
【输入形式】

2003
【输出形式】

3414.6

public class CompanyTest
{
	public static void main(String [] args){
		int year=0;
		Scanner read = new Scanner(System.in);
		Company myCompany = new Company();
myCompany.myCars= new rentCar[3];
        myCompany.setTotalCars(30,10,5);

		if(read.hasNextInt())
			year = read.nextInt();
		System.out.println(myCompany.getTotalMoney(year)/10000);
	}
}

class rentCar
{
	float earnMoney(int year)
          {
            return 0;
          }

	int getDaysofYear(int year)
	{
if(year%4==0 && year%100!=0 || year%400==0 )
            return 366;
        else 
            return 365;

	}
}

class Taxi extends rentCar
{
int TaxiNumber;
    Taxi(int a){
        this.TaxiNumber=a;
    }
    public int getTaxiNumber() {
        return TaxiNumber;
    }
}
class Bus extends rentCar
{
int BusNumber;
    Bus(int a){this.BusNumber=a;}
    public int getBusNumber(){return BusNumber;}
}
class Truck extends rentCar
{
int TruckNumber;
    Truck(int a){this.TruckNumber=a;}
    public int getTruckNumber(){return TruckNumber;}
}

class Company
{
	final int startYear = 2000;
	final int endYear = 2020;
	rentCar [] myCars;
	void setTotalCars(int TaxiNumber,int BusNumber,int TruckNumber)
	{
myCars[0]=new Taxi(TaxiNumber);
        myCars[1]=new Bus(BusNumber);
        myCars[2]=new Truck(TruckNumber);

	}
	double getTotalMoney(int year)
	{
double money=0;
        int days=new rentCar().getDaysofYear(year);
        double taxiIncome=((Taxi)myCars[0]).getTaxiNumber()*180*days;
        double busIncome=((Bus)myCars[1]).getBusNumber()*500*80*12;
        double truckIncome=((Truck)myCars[2]).getTruckNumber()*3.5*30000*days/7;
        money=taxiIncome+busIncome+truckIncome;
        return money;

	}
}

因为是计算年份的营业额，所以不用考虑具体月份的天数，只要计算是否为闰年即可，其他的只是计算方式不同，并没什么很大的区别