先执行父类构造方法，再执行子类构造方法

package dadadache;
/**
 * 车的父类
 */
public abstract class Car {
protected int id;// 车的id
protected String name;// 车的名字
protected double price;// 车的价格
public Car(int id, String name, double price) {
setId(id);
setName(name);
setPrice(price);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return id + ".\t" + name + "\t" + price + "元/天" + "\t";
}
}
package dadadache;
/**
 * 客车
 */
public class Bus extends Car {
private int capacity;// 载人
public Bus(int id, String name, double price, int capacity) {
super(id, name, price);
setCapacity(capacity);
}
public int getCapacity() {
return capacity;
}
public void setCapacity(int capacity) {
this.capacity = capacity;
}
@Override
public String toString() {
return super.toString() + "载人：" + capacity + "人";
}
}
package dadadache;
/**
 * 货车
 */
public class Truck extends Car {
private double load; //载物
public Truck(int id, String name, double price, double load) {
super(id, name, price);
setLoad(load);
}
public double getLoad() {
return load;
}
public void setLoad(double load) {
this.load = load;
}
@Override
public String toString() {
return super.toString() + "载货：" + load + "吨";
}
}
package dadadache;
/**
 * 皮卡
 */
public class PickUp extends Car {
private int capacity;// 载人
private double load; //载物
public PickUp(int id, String name, double price, int capacity, double load) {
super(id, name, price);
setCapacity(capacity);
setLoad(load);
}
public int getCapacity() {
return capacity;
}
public void setCapacity(int capacity) {
this.capacity = capacity;
}
public double getLoad() {
return load;
}
public void setLoad(double load) {
this.load = load;
}
@Override
public String toString() {
return super.toString() + "载人：" + capacity + "人" + " 载货：" + load + "吨";
}
}
package dadadache;
import java.util.Scanner;
public class Driver {
private void printAllCars(Car[] cars) {
for (Car car: cars) {
System.out.println(car);
}
}
public static void main(String[] args) {
System.out.println("欢迎使用哒哒租车系统:");
        System.out.print("您是否要租车：1.是 0.否");
        
        Car[] cars = {new Bus(1, "奥迪A4", 400, 4), new Bus(2, "马自达6", 400, 4),
        new PickUp(3, "皮卡雪6", 450, 4, 2), new Bus(4, "金龙", 800, 20),
        new Truck(5, "松花江", 400, 4), new Truck(4, "依维柯", 1000, 20)};
        
        Scanner scan = new Scanner(System.in);
        int option = scan.nextInt();//获取控制台上用户输入的数字
        
        if (option == 1) {
        Driver driver = new Driver();
       
        System.out.println("您可租车的类型及价目表：");
            System.out.println("序号\t汽车名称\t租金\t\t容量");
            driver.printAllCars(cars);
            
            System.out.print("请输入您要租汽车的数量：");
            int num = scan.nextInt();
            Car[] rentCars = new Car[num];
            int count = 0, totalCapacity = 0; // 车的总数以及总载人量
            double totalLoad = 0, totalPrice = 0; // 总载物量以及总价
            String bus = " ";
            String truck = " ";
            
            outer:
            while(count < rentCars.length) {
            System.out.print("请选择第" + (count + 1) + "辆车的序号");
            int index = scan.nextInt();
            // 检查序号是否正确，如果不正确继续循环
            if (index < 1 || index > cars.length) {
            System.out.print("请输入正确的序号");
            continue outer;
            }
            // 将想租的车的信息放到租车数组，增加count，更新载人/载物信息和价格
            Car car = cars[index-1];
            rentCars[count] = car;
           
            if (car instanceof Bus) {
            totalCapacity += ((Bus) car).getCapacity();
            bus += car.getName();
            } else if (car instanceof Truck) {
            totalLoad += ((Truck) car).getLoad();
            truck += car.getName();
            } else { // 如果是皮卡
            totalCapacity += ((PickUp) car).getCapacity();
            totalLoad += ((PickUp) car).getLoad();
            bus += car.getName();
            truck += car.getName();
            }
            totalPrice += car.getPrice();
           
            count++;
}
            
            System.out.print("请输入租的天数：");
            int days = scan.nextInt();
            totalPrice *= days;
            
            System.out.println("您的账单：");
            System.out.println("***可载人的车有：\n" + bus + "\t共载人" + totalCapacity + "人\n" 
            + "***可载货的车有：\n" + truck + "\t共载货" + totalLoad + "吨\n"
            + "***租车总价格金额：" + totalPrice + "元");
//            driver.printAllCars(rentCars);
        }
        
        scan.close();
}
}

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：

运行结果为：

从上面的代码中我们可以看到，成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

抽象类一般为父类，作用是指定子类必须有哪些方法

public abstract class Father{

public abstract viod Way();

}意思是指定子类必须有Way方法

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

float型变量赋值时需要加f，否者默认浮点型数是double型

多态的多种形态

object类equals方法

object类的tostring方法

object类简介

super的应用大全

super的应用

super关键字