继承加多态就能解决 一开始想着加个pickup接口完成 走进了死胡同，

借鉴了下其他人的代码总算是实现了

public abstract class Car {

private String carName;//汽车名称

private int rent;//租金

private int person;//人数

private int ton;//载重

public String getCarName() {

return carName;

}

public void setCarName(String carName) {

this.carName = carName;

}

public int getRent() {

return rent;

}

public void setRent(int rent) {

this.rent = rent;

}

public int getPerson() {

return person;

}

public void setPerson(int person) {

this.person = person;

}

public int getTon() {

return ton;

}

public void setTon(int ton) {

this.ton = ton;

}

}

public class PassengerCar extends Car {

public  PassengerCar(String carName,int rent,int person,int ton) {

this.setCarName(carName);

this.setRent(rent);

this.setPerson(person);

this.setTon(ton);

}

@Override

public String toString() {

return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

}

}

public class Truck extends Car {

public  Truck(String carName,int rent,int person,int ton) {

this.setCarName(carName);

this.setRent(rent);

this.setPerson(person);

this.setTon(ton);

}

@Override

public String toString() {

return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

}

}

public class Pickup extends Car {

public  Pickup(String carName,int rent,int person,int ton) {

this.setCarName(carName);

this.setRent(rent);

this.setPerson(person);

this.setTon(ton);

}

@Override

public String toString() {

return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

}

}

import java.util.Scanner;

public class dada {

public static void main(String[] args) {

// TODO Auto-generated method stub

Car[] cars= {

new PassengerCar("奥迪A4",500,4,0),

new PassengerCar("马自达6",400,4,0),

new Pickup("皮卡雪6",450,4,2),

new PassengerCar("金龙",800,20,0),

new Truck("松花江",400,0,4),

new Truck("依维柯",1000,0,20)

};

System.out.println("欢迎使用达达租车系统！\n您是否要租车:yes/no");

Scanner input=new Scanner(System.in);

String decide=input.next();

if("yes".equals(decide)) {

System.out.println("您可租车的类型及其价目表:\n序号\t汽车名称   租金\t容量 ");

for(int i=0;i<cars.length;i++) {

System.out.println((i+1)+"\t"+cars[i]);

}

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

int num=input.nextInt();

int serial;

Car[] newCar=new Car[num];

for(int i=0;num>0;num--,i++) {

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

serial=input.nextInt();

newCar[i]=cars[serial-1];

}

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

int day=input.nextInt();

System.out.println("您的账单:");

System.out.println("***可载人的车有:");

int totalPerson = 0;

int totalTon = 0;

for(int j=0;j<newCar.length;j++) {

if(newCar[j].getPerson()>0) {

System.out.println(newCar[j].getCarName()+"\t");

totalPerson+=newCar[j].getPerson();

}

}

System.out.println("**载货的车有:");

for(int j=0;j<newCar.length;j++) {

if(newCar[j].getTon()>0) {

System.out.println(newCar[j].getCarName()+"\t");

totalTon+=newCar[j].getTon();

}

}

System.out.println("***租金总价格:");

int totalRent=0;

for(int k=0;k<newCar.length;k++) {

totalRent+=newCar[k].getRent();

}

System.out.println(totalRent*day);

}

}

}

/** * 建父类文件Car，再建三个子类文件，分别是：Huoche，Keche，Pikache * 定义父类拥有三个子类都有的属性，分别是：列序号number，品牌pinpai，车的每天租金zujin，车的载人容量zairen，车的载货容量zaihuo * 自定义父类的三个带参构造方法接收属性赋值，让子类创建对象并赋值时对号入座，每个子类只需用到一个构造方法 * 定义父类的普通方法，打印以上各个属性的值 * 创建程序入口文件 */

-----接口-----接口取名字一般前面加一个IPlayGame 1.接口概念 类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。 2.接口的定义 和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。 3.接口定义的基本语法: [修饰符] [abstract] interface 接口名 [extends 父接口1，父接口2...] { 零个到多个常量定义... 零个到多个抽象方法的定义...(抽象方法的abstract会自动加) } 接口就是用来被继承、被实现的，修饰符一般建议用public 注意:不能使用private和protected修饰接口 4.使用接口 一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。 [修饰符] class 类名 extends 父类 implement 接口1，接口2... { 类体部分//如果继承了抽象类，需要实现继承的抽象方法;要实现接口中的抽象方法。 } 接口的引用： IPlayGame ip1=new SmartPhone(); ip1.playGame(); IPlayGame ip2=new Psp(); ip2.playGame();

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。<br> 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。<br> 创建对象的时候就会加载类，就会出现任务结果的前三行。 <br> 程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

1.对象的概念 客观存在的是事物皆为对象。 具体存在事物为对象。 2.面向对象 人更关注具体事物的信息。 描述买电话的过程称为面向对象。 3.类 模型，用来描述对象的特征（属性）和行为（方法）。 对象就是计算机中的具体信息。 累就是这个信息的类型。 具有相同属性和方法的一组对象的集合。 4.对象的属性 对象拥有的各种特征（有什么）。 例如手机的屏幕，cpu,内存等等。 5.对象的方法 对象执行的操作（能干什么）。 6。类和对象的关系/区别 类是抽象的概念，模板。描述具体的对象信息。 对象是具体实体，客观存在。

JAVA中四种访问权限 private<default<protected<public，如果子去重写父的方法，方法的权限默认是和父一样的，但也可以改，但只能加大权限，不能缩小权限，比如父是protected,重写时可以改成public，但如果是public的，重写只能是public

Syso Alt+/ 自动补全输入代码

HelloWorld.nane和HelloWorld.this.name区别在于， 第一个语句是非法的，想要这样表述，必须对类进行实例化然后再访问它的成员变量：HelloWorld hello=new HelloWorld();hello.name 而第二个语句恰恰就是实现这样的功能，这样就能体现this的作用了

我觉得这一章应该说明一下这样做有什么用，否则这个内容很容易学完就会被忘记，我在这就顺手说明一下这样做的意义吧，希望被顶上，让更多人看见。初始化块就是构造器的补充，初始化块是不能接收任何参数的，定义的一些所有对象共有的属性、方法等内容时就可以用初始化块了初始化！！ 好处是可以提高初始化块的复用，提高整个应用的可维护性。--《疯狂java讲义》

多态的应用：用父类数组存储多个子类对象 父类[] 引用名={new 子类1（），new子类2（）......new 子类n（）}

Dog dog = new Dog(); Animal dog = new Dog();都可以，但是 Dog dog = new Animal();就不可以了，体现了继承的单向性。

继承时候，会纠结父类到底是使用class、abstract class还是interface： 普通class：当父类的方法具有通用性，子类很少重写的情况下，使用普通的class作为父类，这样逻辑就保留在父类，供子类调运即可。 抽象类abstract class：当父类存在部分方法必须在子类进行重写，父类不需要初始化方法逻辑的时候，使用抽象类 接口interface：当针对一批类，制定一套标准和规范的时候，使用接口，接口只定义，不实现。具体的实现全部在子类进行重写。

访问修饰符：用于修饰属性和方法的访问范围。 访问修饰符的总结： private（私有）：本类可访问。 default（默认）：本类、同包可访问。 protected（保护）：本类、同包、子类可访问。 public（公开）：本类、同包、子类、其他可访问。

静态初始化块最先执行且只执行一次，然后普通初始化块，然后构造方法

静态方法是属于类的，内存必须为它分配内存空间，这个空间一直由静态方法占用，内存管理器不会由于静态方法没有被调用而将静态方法的存储空间收回，这样如果将所有的方法都声明为静态方法，就会占用大量的内存空间，最后是系统变慢。而普通的成员方法是由对象调用的，内存并不会一直为起分配内存，只有调用的时候才为其分配存储空间，而当其没有被调用时，存储空间就会被内存管理其收回，释放没有用的空间，提高的系统的运行速率！