答答租车控制台控制台练手

答答租车控制台

car.java

package Jack_Cui;
/*
 * Project:             Lease System
 * Comments:            汽车类，客车、货车、皮卡车的基类
 * JDK version used:    JDK1.8
 * Author:              Jack-Cui
 * Create Date:         2016-8-29
 */
public class Car {          
    private String s_name;  //汽车名
    private int i_price;    //汽车租赁价格
    /*类外访问，需要通过set、get方法写/读数据成员s_name、i_price*/
    public String getName() {
        return s_name;
    }
    public void setName(String name) {
        this.s_name = name;
    }
    public int getPrice() {
        return i_price;
    }
    public void setPrice(int price) {
        this.i_price = price;
    }
}


Lease.java

package Jack_Cui;
import java.util.Scanner;           //导入Scanner，获取用户输入信息

/*
 * Project:             Lease System
 * Comments:            租赁
 * JDK version used:    JDK1.8
 * Author:              Jack-Cui
 * Create Date:         2016-8-29
 */
public class Lease {
    public static void main(String[] args){
        System.out.println("欢迎使用答答租车系统\n您是否要租车：1是\t0否");        //打印提示信息
        int i_finalPrice = 0;                               //最终总价格
        int i_finalPersonNum = 0;                           //最终总载客量
        int i_finalGoodsNum = 0;                            //最终总载货量
        StringBuffer bufer_sBusName = new StringBuffer();   //记录租车的名字
        StringBuffer bufer_sTrunkName = new StringBuffer(); //记录租车的名字

        Scanner input = new Scanner(System.in);             //获取用户输入信息
        if(input.nextInt() != 1){
            System.out.println("谢谢光临，再会！");
            input.close();                                  //关闭用户输入
            return;
        }
        System.out.println("您可租车的类型及其价目表：\n序号\t汽车名称\t租金\t容量");
        Bus car1 = new Bus("奥迪A4",500,4);               //实例化奥迪A4
        Bus car2 = new Bus("马自达6",400,4);               //实例化马自达6
        Bus car3 = new Bus("金龙",800,20);                //实例化金龙
        Trunk car4 = new Trunk("松花江",400,4);            //实例化松花江
        Trunk car5 = new Trunk("依维柯",1000,20);          //实例化依维柯
        Pickup car6 = new Pickup("皮卡雪6",450,4,2);       //实例化皮卡雪6
        Car[] cars = {car1,car2,car3,car4,car5,car6};
        /*展示车辆信息*/
        for(int i = 0; i < cars.length; i++){
            System.out.println((i + 1) + ".\t" + cars[i].toString());
        }
        System.out.println("请输入您要租汽车的数量：");
        int i_num = input.nextInt();                        //记录租车数量
        int[] i_car = new int[i_num];                       //记录租车序号
        for(int i = 0; i < i_num; i++){
            System.out.println("请输入第" + (i + 1) + "辆车的序号：");
            int i_key = input.nextInt();
            if(i_key >=1 && i_key <= 6){
                i_car[i] = i_key;
            }else{
                System.out.println("您输入的序列有误，请重新输入(1-6):");
                i--;                                    //输入错误，重新输入
            }
        }
        for(int  i = 0; i < i_car.length ; i++){
            switch(i_car[i]){
            case 1:
                bufer_sBusName.append(car1.getName() + "  ");
                i_finalPrice += car1.getPrice();
                i_finalPersonNum += car1.getI_PersonNum();
                break;
            case 2:
                bufer_sBusName.append(car2.getName() + "  ");
                i_finalPrice += car2.getPrice();
                i_finalPersonNum += car2.getI_PersonNum();
                break;
            case 3:
                bufer_sBusName.append(car3.getName() + "  ");
                i_finalPrice += car3.getPrice();
                i_finalPersonNum += car3.getI_PersonNum();
                break;
            case 4:
                bufer_sTrunkName.append(car4.getName() + "  ");
                i_finalPrice += car4.getPrice();
                i_finalGoodsNum+= car4.getI_GoodsNum();
                break;
            case 5:
                bufer_sTrunkName.append(car5.getName() + "  ");
                i_finalPrice += car5.getPrice();
                i_finalGoodsNum += car5.getI_GoodsNum();
                break;
            case 6:
                bufer_sBusName.append(car6.getName() + "  ");
                bufer_sTrunkName.append(car6.getName() + "  ");
                i_finalPrice += car6.getPrice();
                i_finalPersonNum += car6.getI_PersonNum();
                i_finalGoodsNum += car6.getI_GoodsNum();
                break;
            default:
                break;
            }
        }
        System.out.println("请输入租车天数：");
        int days = input.nextInt();
        //最终信息输出
        System.out.println("您的账单：\n***可载人的车有：");
        System.out.println(bufer_sBusName + "共载人：" + i_finalPersonNum + "人");
        System.out.println("***载货的车有：\n" + bufer_sTrunkName + "共载货：" + i_finalGoodsNum + "吨");
        System.out.println("***租车总价格：" + i_finalPrice * days);
        System.out.println("感谢使用答答租车系统");
        input.close();      //关闭用户输入
    }
}
/*
 * Project:             Lease System
 * Comments:            客车类，继承于汽车类
 * JDK version used:    JDK1.8
 * Author:              Jack-Cui
 * Create Date:         2016-8-29
 */
class Bus extends Car {                 //访问修饰符(默认):可在本类、同包中使用
    private int i_PersonNum;            //客车类载人容量
    public Bus(String name, int price, int PersonNum){      //有参构造方法
        super();                        //如果没有，系统默认调用
        super.setName(name);            //设置客车名称
        super.setPrice(price);          //设置客车租赁价格
        this.i_PersonNum = PersonNum;   //设置客车容量
    }
    /*类外访问，需要通过set、get方法写/读数据成员i_PersonNum*/
    public int getI_PersonNum() {
        return i_PersonNum;
    }
    public void setI_PersonNum(int i_PersonNum) {
        this.i_PersonNum = i_PersonNum;
    }
    @Override
    public String toString() {
        return this.getName() + "\t" + this.getPrice() + "元/天\t载人:" + i_PersonNum + "人";
    }
}
/*
 * Project:             Lease System
 * Comments:            货车类，继承于汽车类
 * JDK version used:    JDK1.8
 * Author:              Jack-Cui
 * Create Date:         2016-8-29
 */
class Trunk extends Car{
    private int i_GoodsNum;             //货车的载货量
    public Trunk(String name, int price, int GoodsNum){     //有参构造方法
        super();                        //如果没有，系统默认调用
        super.setName(name);            //设置货车名称
        super.setPrice(price);          //设置货车租赁价格
        this.i_GoodsNum = GoodsNum;     //设置货车载货量
    }
    /*类外访问，需要通过set、get方法写/读数据成员i_GoodsNum*/
    public int getI_GoodsNum() {
        return i_GoodsNum;
    }
    public void setI_GoodsNum(int i_GoodsNum) {
        this.i_GoodsNum = i_GoodsNum;
    }
    @Override
    public String toString() {
        return this.getName() + "\t" + this.getPrice() + "元/天\t载货:" + i_GoodsNum + "吨";
    }
}
/*
 * Project:             Lease System
 * Comments:            皮卡类，继承于汽车类
 * JDK version used:    JDK1.8
 * Author:              Jack-Cui
 * Create Date:         2016-8-29
 */
class Pickup extends Car{
    private int i_PersonNum;            //客车类载人容量
    private int i_GoodsNum;             //货车的载货量
    public Pickup(String name, int price, int PersonNum, int GoodsNum){
        super();                        //如果没有，系统默认调用
        super.setName(name);            //设置皮卡名称
        super.setPrice(price);          //设置皮卡租赁价格
        this.i_PersonNum = PersonNum;   //设置皮卡载人量
        this.i_GoodsNum = GoodsNum;     //设置皮卡载货量
    }
    /*类外访问，需要通过set、get方法写/读数据成员i_PersonNum、i_GoodsNum*/
    public int getI_PersonNum() {
        return i_PersonNum;
    }
    public void setI_PersonNum(int i_PersonNum) {
        this.i_PersonNum = i_PersonNum;
    }
    public int getI_GoodsNum() {
        return i_GoodsNum;
    }
    public void setI_GoodsNum(int i_GoodsNum) {
        this.i_GoodsNum = i_GoodsNum;
    }
    @Override
    public String toString() {
        return this.getName() + "\t" + this.getPrice() + "元/天\t载人:" + i_PersonNum + "人\t载货:" + i_GoodsNum;
    }
}

StringBuffer的用法
1、StringBuffer对象的初始化
StringBuffer对象的初始化不像String类的初始化一样，Java提供的有特殊的语法，而通常情况下一般使用构造方法进行初始化。
例如：
StringBuffer s = new StringBuffer();
这样初始化出的StringBuffer对象是一个空的对象，就是我犯的错误。
如果需要创建带有内容的StringBuffer对象，则可以使用：
StringBuffer s = new StringBuffer(“abc”);
这样初始化出的StringBuffer对象的内容就是字符串”abc”。
需要注意的是，StringBuffer和String属于不同的类型，也不能直接进行强制类型转换，下面的代码都是错误的：
StringBuffer s = “abc”; //赋值类型不匹配
StringBuffer s = (StringBuffer)”abc”; //不存在继承关系，无法进行强转
StringBuffer对象和String对象之间的互转的代码如下：
String s = “abc”;
StringBuffer sb1 = new StringBuffer(“123”);
StringBuffer sb2 = new StringBuffer(s); //String转换为StringBuffer
String s1 = sb1.toString(); //StringBuffer转换为String
2、StringBuffer的常用方法
StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，这个也是StringBuffer和String类的主要区别。
a、append方法
public StringBuffer append(boolean b)
该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变，例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
则对象sb的值将变成”abctrue”。
使用该方法进行字符串的连接，将比String更加节约内容，例如应用于数据库SQL语句的连接，例如：
StringBuffer sb = new StringBuffer();
String user = “test”;
String pwd = “123”;
sb.append(“select * from userInfo where username=“)
.append(user)
.append(“ and pwd=”)
.append(pwd);
这样对象sb的值就是字符串“select * from userInfo where username=test and pwd=123”。
b、deleteCharAt方法
public StringBuffer deleteCharAt(int index)
该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“Test”);
sb. deleteCharAt(1);
该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变为”Tst”。
还存在一个功能类似的delete方法：
public StringBuffer delete(int start,int end)
该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb. delete (1,4);
该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。
c、insert方法
public StringBuffer insert(int offset, boolean b)
该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false);
该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。
d、reverse方法
public StringBuffer reverse()
该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.reverse();
经过反转以后，对象sb中的内容将变为”cba”。
e、setCharAt方法
public void setCharAt(int index, char ch)
该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.setCharAt(1,’D’);
则对象sb的值将变成”aDc”。
f、trimToSize方法
public void trimToSize()
该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费。
总之，在实际使用时，String和StringBuffer各有优势和不足，可以根据具体的使用环境，选择对应的类型进行使用。