项目分析：

一.项目背景介绍

二.项目分析：

1,。数据模型分析：通过对现实世界的事与物主要的特征的分析，抽象，为信息系统的实施提供数据存取的数据结构以及相应的约束、

数据结构组成：操作（方法），属性

2.业务模型分析：在设计应用程序之前，应该明确该应用程序必须执行哪些任务。（业务需求分析）

3.显示和流程分析：显示：视图，流程：显示信息的执行过程与步骤。

UML

1. UML概念：

     统一建模语言或标准建模语言，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。

2. UML图示 UML2.2中一共定义了14种图示。

3. 常用UML图

   a.用例图（TUCD） 用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求信息。

   b.序列图（TSD） 序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互。

   c.类图（TCD） UML类图，业务逻辑和所有支持结构一同被用于定义全部的代码结构。

4. UML建模工具：Visio,Rational Rose,PowerDesign.

接口

1. 接口概念：

   接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

   类是一种具体的实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

2. 接口定义：

   和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。

   接口就是用来被继承，被实现的，修饰符一般建议用public，不能使用private和protected修饰接口。

   接口可以多继承，基本语法：（[]为可选项）

   [修饰符] [abstract] interface 接口名 [extends 父接口1，父接口2..]{

   零到多个常量定义..

   零到多个抽象方法定义..

   }

   接口名一般命名首写I字母表示为接口。

   常量：接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上。

   方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上。

3. 使用接口

    一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

   接口没有构造方法，不能实例化，只能通过引用指向实现对象。

抽象类

1. 语法定义：抽象类前使用abstract关键字修饰，则该类为抽象类。

2. 应用场景：a.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。（抽象类约束子类必须拥有哪些方法，并不关注子类怎样去实现）

                   b.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

3. 作用：限制规定子类必须实现某些方法，但不关注实现细节。

4. 使用规则：a. abstract定义抽象类

                         b. abstract定义抽象方法，只有声明，不需要实现（没有{方法体}）

                         c. 包含抽象方法的是抽象类，但抽象类中可以包含普通方法，也可以没有抽象方法。

                          d.抽象类是有构造方法的，但不能实例化！抽象类不能直接创建，可以定义引用变量指向子类对象。

多态中的引用类型转换

1. 向上类型转换（自动/隐式类型转换）

2. 向下类型转换（强制类型转换）注意引用类型和对象类型要匹配，可以通过instanceof运算符避免类型转换的安全性问题。

   instanceof运算符 可以判断一个引用是否是另一个类的类型或子类型。

多态：对象的多种形态（继承是多态的基础）

1. 引用多态 

   父类的引用可以指向本类的对象

   父类的引用可以指向子类的对象

2. 方法多态

   创建本类对象时，调用的方法为本类方法

   创建子类对象时，调用的方法为子类重写的方法或者继承的方法（子类没有重写该方法）

Object类

常用方法：

2.equals(）方法  比较的是对象的引用是否指向同一块内存地址（同==）

可通过重写equals(）方法来比较两个类的对象的属性值是否相等。

3.getClass()方法 返回一个类对象

类的对象和类对象有区别：

类的对象用new构造方法来实例化，类的对象描述的是类的数据信息（属性值）。

类对象用getClass()方法得到，类对象描述的是类的代码信息（属性和方法）

Object类

Object类是所以类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。

Object类中的方法，适合所有子类。

Object类重要的几个方法：

1. toString()方法 在Object类里面定义toString()方法的时候返回对象的哈希code码（对象地址字符串）。

   可以通过重写toString（）方法表示出对象的属性。

super关键字的应用

子类的构造的过程当中必须调用其父类的构造方法。

如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法（隐式调用父类构造方法）。

如果显示的调用构造方法，必须在子类构造方法的第一行。（super();放第一行）

如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。（在编写类的构造方法中，一旦编写了有无参数的构造方法，系统不会默认创建类的无参构造方法，即父类编写了有参数的构造方法时，子类的构造方法要显示调用父类构造方法）。

final关键字可以修饰类，方法，属性和变量，有“最终的”含义

final修饰类，则该类不允许被继承。

final修饰方法，则该方法不允许被覆盖（重写）

final修饰属性，1.则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）          2.或在构造方法中赋值（2选1）

final修饰变量，则该变量的值只能赋一次值。即变为常量。

继承的初始化顺序：

1. 初始化父类再初始化子类

2. 先执行初始化对象中属性，再执行构造方法中的初始化。

package com.com.rentCar;

public abstract class Car {
    public double price;
    public String name;

    public abstract String toString();
}

package com.com.rentCar;

public class BusCar extends Car {
    private int content;//人

    public int getContent() {
        return content;
    }

    public BusCar(String name,double price, int content) {
        this.name = name;
        this.price = price;
        this.content = content;
    }

    @Override
    public String toString() {
        return this.name + "\t\t" + this.price + "元/天\t\t"  + "载人：" + this.content + "人";
    }
}

package com.com.rentCar;

public class TruckCar extends Car {
    private int content;//货

    public int getContent() {
        return content;
    }

    public TruckCar(String name, double price,int content) {
        this.name = name;
        this.price = price;
        this.content = content;
    }

    @Override
    public String toString() {
        return this.name + "\t\t" + this.price + "元/天\t\t" + "载货：" + this.content + "吨";
    }
}

package com.com.rentCar;

public class PickCar extends Car {
    private int content;//货
    private int pContent;//人数

    public int getContent() {
        return content;
    }

    public int getpContent() {
        return pContent;
    }

    public PickCar(String name, double price, int content,int pContent) {
        this.name = name;
        this.price = price;
        this.content = content;
        this.pContent = pContent;
    }

    @Override
    public String toString() {
        return this.name + "\t\t" + this.price + "元/天\t\t"  + "载人：" + this.pContent + "人 载货：" + this.content + "吨";
    }
}

package com.com.rentCar;

import java.util.Scanner;

public class Test {
    public Scanner scanner;
    public Car[] cars;

    public Test(Car[] cars) {
        this.cars = cars;
        this.scanner = new Scanner(System.in);
    }

    public static void main(String[] args) {
        Car car = new BusCar("奥迪A4",500,4);
        Car car1 = new BusCar("马自达6",500,4);
        Car car2 = new PickCar("皮卡雪6",450,4,2);
        Car car3 = new BusCar("金龙 ",800,20);
        Car car4 = new BusCar("松花江",400,4);
        Car car5 = new BusCar("依维柯",1000,20);
        Car[] cars = {car, car1, car2, car3, car4, car5};
        Test test = new Test(cars);
        test.start();
    }

    public void start() {
        //欢迎
        welcome();

        //是否租车
        if (checkNext() == false) {
            bye();
            return;
        }

        //车列表
        showCarList();

        //租车数量
        int num = 0;
        do {
            num = chooseNum();
        } while (num == 0);

        //选择
        int[] chooseCars = new int[num];
        int next = 1;
        while (next <= num) {
            chooseCars[next-1] = chooseCar(next);
            next += 1;
        }

        //租车天数
        int day = 0;
        do {
            day = chooseDay();
        } while (day == 0);

        //账单
        showBill(chooseCars,day);

        bye();
    }

    public void welcome() {
        System.out.println("欢迎使用嗒嗒租车系统");
    }

    public void bye() {
        System.out.println("谢谢使用");
    }

    public boolean checkNext() {
        System.out.println("你是否要租车：1是0否");
        int choose = this.scanner.nextInt();
        return choose==1;
    }

    public void showCarList() {
        System.out.println("你可租车的类型及价目表");
        System.out.println("序号\t\t汽车名称\t\t租金\t\t容量");
        for (int i = 0; i < cars.length; i++) {
            Car car = cars[i];
            System.out.println((i+1) + ".\t\t" + car.toString());
        }
    }

    public int chooseNum() {
        System.out.println("请输入你要租车的数量：");
        return scanner.nextInt();
    }

    public int chooseCar(int next) {
        System.out.println("请输入第" + next + "辆车的序号：");
        return scanner.nextInt();
    }

    public int chooseDay() {
        System.out.println("请输入租车天数：");
        return scanner.nextInt();
    }

    public void showBill(int[] carIds, int day) {
        System.out.println("您的账单：");
        double allPrices = 0;
        int peoNum = 0;
        int goodsNum = 0;
        //载人车辆统计
        String peopleCar = "***可载人的车有：\n\t";
        //载货车辆统计
        String goodsCar = "***可载货的车有：\n\t";
        for (int i = 0; i < carIds.length; i++) {
            if (this.cars.length <= i) {
                break;
            }
            int carId = carIds[i];
            Car car = this.cars[carId];
            allPrices += car.price * day;
            if (car.getClass() == BusCar.class) {
                peopleCar += car.name;
                peopleCar += " ";
                peoNum += ((BusCar)car).getContent();
            }

            if (car.getClass() == TruckCar.class) {
                goodsCar += car.name;
                goodsCar += " ";
                goodsNum += ((TruckCar)car).getContent();
            }

            if (car.getClass() == PickCar.class) {
                peopleCar += car.name;
                peopleCar += " ";
                peoNum += ((PickCar)car).getpContent();

                goodsCar += car.name;
                goodsCar += " ";
                goodsNum += ((PickCar)car).getContent();
            }
        }

        if (peoNum > 0) {
            System.out.println(peopleCar);
        }
        if (goodsNum > 0) {
            System.out.println(goodsCar);
        }
        System.out.println("***租车总价格：" + allPrices + "元");
    }
}

方法的重写：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法是会优先调用子类的方法。

语法规则：返回值类型，方法名，参数类型及个数顺序都要与父类继承的方法相同，才叫方法的重写。

继承是类与类的一种关系，Java中的继承是单继承。

继承的好处：子类拥有父类的所有属性和方法（private修饰符修饰的属性和方法子类不能继承），实现代码复用。

语法规则：class 子类 extends 父类{};

类是抽象概念，仅仅是模板，对象是实体，看得见摸得着，比如“手机”是类，“苹果”、“三星”是对象