反反复复放反反复复放丰富

啊啊啊啊啊啊啊

父类：

package com.imooc;

public abstract class Car {

private int ID;

private String name;

public float price;

public Car(int iD, String name, float price) {

this.setID(iD);

this.setName(name);

this.setPrice(price);

}

public int getID() {

return ID;

}

public void setID(int iD) {

ID = iD;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public float getPrice() {

return price;

}

public void setPrice(float price) {

if(price<0) {

return;

}

this.price = price;

}

public abstract void run();

}

子类1：

package com.imooc;

public class Auotomobile extends Car {

private int busload;

public Auotomobile(int iD, String name, float price,int busload) {

super(iD, name, price);

this.setBusload(busload);

}

public int getBusload() {

return busload;

}

public void setBusload(int busload) {

this.busload = busload;

}

@Override

public void run() {

System.out.println(this.getID()+"\t"+this.getName()+" \t"

+this.getPrice()+"元/天 \t载人："+this.getBusload()+"人");

}

}

子类2

package com.imooc;

public class Trucks extends Car {

private double botaload;

public Trucks(int iD, String name, float price,double botaload) {

super(iD, name, price);

this.setBotaload(botaload);

}

public double getBotaload() {

return botaload;

}

public void setBotaload(double botaload) {

this.botaload = botaload;

}

@Override

public void run() {

System.out.println(this.getID()+"\t"+this.getName()+"\t"

+this.getPrice()+"元/天\t载货："+this.getBotaload()+"吨");

}

}

子类3

package com.imooc;

public class Pick extends Car {

private int busload;

private double botaload;

public Pick(int iD, String name,float price,

int busload,double botaload) {

super(iD, name, price);

this.setBusload(busload);

this.setBotaload(botaload);

}

public double getBotaload() {

return botaload;

}

public void setBotaload(double botaload) {

this.botaload = botaload;

}

public int getBusload() {

return busload;

}

public void setBusload(int busload) {

this.busload = busload;

}

@Override

public void run() {

System.out.println(this.getID()+"\t"+this.getName()+"\t"

+this.getPrice()+"元/天\t载人："+this.getBusload()+"人  载货："+this.getBotaload()+"吨");

}

}

测试类

package com.test;

import java.util.Scanner;

import com.imooc.Auotomobile;

import com.imooc.Car;

import com.imooc.Pick;

import com.imooc.Trucks;

public class Test {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("欢迎使用答答租车系统：");

System.out.println("你是否要租车：是  否");

String sf = sc.next();

if(sf.equals("是")) {

while(sf.equals("是")) {

Car[] car = {new Auotomobile(1,"奥迪A4",500f,4),

new Auotomobile(2,"马自达6",400f,4),

new Pick(3,"皮卡雪6",450f,4,2),

new Auotomobile(4,"金龙",800f,20),

new Trucks(5,"松花江",400f,4),

new Trucks(6,"依维柯",1000f,20),};

float price = 0;

int busload = 0;

double botaload = 0;

System.out.println("您可租车的类型及其价目表：");

System.out.println("序号\t汽车名称\t租金\t\t容量");

for(Car c :car) {

c.run();

}

System.out.println("请输入您要租汽车的数量：");

int number = sc.nextInt();

Car[] laycar = new Car[number];

for(int i =0;i<number;i++) {

System.out.println("请输入第"+(i+1)+"辆车的序号");

int xh = sc.nextInt();

laycar[i] = car[xh-1];

}

System.out.println("您选择的车辆有：");

for(Car r:laycar) {

r.run();

price += r.getPrice();

if(r instanceof Auotomobile) {

busload += ((Auotomobile) r).getBusload();

}else if(r instanceof Trucks) {

botaload += ((Trucks) r).getBotaload();

}else if(r instanceof Pick) {

busload +=((Pick) r).getBusload();

botaload +=((Pick) r).getBotaload();

}

}

System.out.println("请输入租车天数：");

int rental = sc.nextInt();

price *= rental;

System.out.println("请查看您的账单：");

System.out.println("可载人："+busload+"人，可载货："+botaload+"吨，总价格："+price+"元");

System.out.println("是否还要租车： 是  否");

sf = sc.next();

}

System.out.println("退出答答租车系统");

}else {

System.out.println("欢迎下次光临");

}

}

}

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

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

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

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

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

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

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

1. 作用域不同

   局部变量的作用域仅限于定义它的方法

   成员变量的作用域在整个类内部都是可见的

2. 初始值不同

   java会给成员变量一个初始值

   java不会给局部变量赋予初始值

3. 在同一方法中，不允许有同名局部变量；在不同的方法中可以有同名的局部变量

4. 两类变量同名时，局部变量具有更高的优先级
   

想要调用内部类的方法，需要执行以下步骤：

1.创建外部类对象

HelloWorld hello = new HelloWorld();

2.创建内部类对象

Inner i = hello.new Inner();

3.调用内部类对象的方法

i.show();