这part 很重要，类与类关系的理解，类与类之间关系的调用，这玩意不写个几千行代码你玩不转但这过程其实很开心，有什么能够比创造更开心的事呢，希望你们也能给自己下这样定义，你们不是码农，你们是创造者，而编程只是你创造的其中一个工具。对其中一个，编程不应该成为你的所有，那这样编程失去它原本的乐趣，抱着爱上它的心态去学习，相信我，不断的coding能让你爱上它
来来先看业务：
业务1：模拟在路上陆陆续续的有车过去，随时有测速器在监测这些车，如果有车超速，就报警通知警车追赶他
分析有三个类：车， 测速器， 警车
因为是陆陆续续过去的所以在内存中肯定是有个车数组吧，这里我用一个类叫做车库管理下这个车的存储和发车经过测速器，测速器有自己的速度标准如果超速了就调用警车，这时候警车也该有个车库吧
这业务里用到的知识点全面：继承，接口，缺省适配器模式，static方法块，多态，封装思想。
package Catchcar;
public interface Car {
//定义一个car接口，毕竟无论是路上跑的车还是警车它都能跑嘛，总不能飞吧
public abstract void running(int speed);
public abstract void running(String carNum,String carBrand,int speed);//方法重载
public abstract int getSpeed();
}
package Catchcar;
public class RunningCar implements Car {
private String carBrand;//汽车品牌
private String carNum;//
private int speed;
public RunningCar(String carBrand,String carNum,int speed){
this.carBrand=carBrand;
this.carNum=carNum;
this.speed=speed;
}
@Override
public void running(int speed) {
//发现问题没，，，接口有这样一个弊端，我只想重写接口的某一个方法，但接口的内部机制必须让我重写，这真的很不方便
//方法解决：建立一个抽象类，实现接口，重写不想让子类重写的类，然后类就只继承这个中间的抽象类，
// 只继承几个你想要重写类就行了，这叫做缺省适配器模式，基本任何框架任何java封装的数据结构都有这个模式
}
@Override
public void running(String carNum,String carBrand,int speed) {//重写Car接口方法
System.out.println("号码为"+carNum+carBrand+"牌汽车"+"以"+speed+"速度行驶");
}
@Override
public int getSpeed() {
return this.speed;
}
}
package Catchcar;
public class PoliceCar implements Car{
//警车的速度---属性，以及他的构造方法
//追车的方法----依赖关系，车是依赖的对象
//获取小汽车速度，根据速度大小判断结果
private int speed;
public PoliceCar(){}
public PoliceCar(int speed){
this.speed=speed;
}
public void catchCar(RunningCar runningCar){
int carspeed=runningCar.getSpeed();
System.out.println("开始追赶目前警车速为"+this.getSpeed());
if(this.speed>carspeed){
int time=(this.speed-carspeed);
System.out.println(time+"后抓到了");
}else{
System.out.println("没抓到");
}
}
@Override
public void running(int speed) {
}
@Override
public void running(String carNum, String carBrand, int speed) {
}
@Override
public int getSpeed() {
return this.speed;
}
}
package Catchcar;
public class CarBase {
//这里我建立一个Car 类型的数组对没错这样数组既能方警车又能放普通车（这就是多态的魅力）
//
private static Car runningCarbase []=new Car[5];
private static Car policeCarbase[]=new Car[5];
static {
//车库进行初始化
//静态块是子类中第一个执行的，要好好理解类的加载顺序
for(int i=0;i<runningCarbase.length;i++){
//明白我为啥数组用静态了么，静态元素不能访问非静态元素
//为什么不能访问也请你理解
runningCarbase[i]=new RunningCar("bentain",""+Math.random(),(int)(Math.random()*10));
// 随机一个数然后把它变成string
// math.random方法是在01之间求随机小数，我把它*10 在强制变成int就能随机出0-10之间的数了
//神奇吧，这就是多态的魅力
}
//上个for循环里面的i变量出了循环后就消失，后面我可以用同样的名字定义变量不会起冲突
for(int i=0;i<policeCarbase.length;i++){
policeCarbase[i]=new PoliceCar(8);
}
}
public static PoliceCar getPoliceCar(){
//遍历一遍车库，如果有车就返回切将该位置变成null
PoliceCar policeCar=null;
for(int i=0;i<policeCarbase.length;i++){
if(policeCarbase[i]!=null){
policeCar=(PoliceCar) policeCarbase[i];//记者车库里的车还是Car类型的，
// 只是指向了policeCar子类能够调用子类属性和子类重写方法。
//以前没得选现在想做个好人，需要你强制转成子类
policeCarbase[i]=null;
break;
}
}
return policeCar;
}
public static RunningCar getRunningCar(){
RunningCar runningCar=null;
for(int i=0;i<runningCarbase.length;i++){
if(runningCarbase[i]!=null){
runningCar =(RunningCar)runningCarbase[i];
runningCarbase[i]=null;
//拿到车了就停止循环
break;
}
}
return runningCar;
}
}
package Catchcar;
public class TextMachine {
//属性 定义好一个标准的时间
//测量小汽车的方法
//超速?的话调用警察追车的构造方法
private int stander=5;
public TextMachine(){}
public void textCar(RunningCar runningcar){
int carSpeed=runningcar.getSpeed();
if(carSpeed>5){
System.out.println("该车速度为"+carSpeed+"出动警车追赶");
PoliceCar PC =CarBase.getPoliceCar();
PC.catchCar(runningcar);
}else {
System.out.println("注意安全");
}
}
}
package Catchcar;
public class TextMaiN {
public static void main (String[]args){
TextMachine textMachine=new TextMachine();
for(int i=0;i<5;i++){
textMachine.textCar(CarBase.getRunningCar());
}
}
}