java实现十字路口交通管理系统

ITISummer

已于 2023-05-29 05:14:45 修改

阅读量4.6k

点赞数 10

分类专栏：我的小项目分享文章标签： java

于 2019-03-10 21:49:35 首次发布

本文链接：https://blog.csdn.net/LCX13141314/article/details/88384596

版权

我的小项目分享专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

这篇博文内容呢是我大二上学期刚学习java的时候我们课任老师给我们出的一道课程设计附加题。完全是原创哦！当时也是抱着试一下的心态去完成的！过程的坎坷就不多说了！都是泪！不过好在坚持下来了，最终完成了这个挺烂的项目！有大佬看见的话先不要评我啊！这个代码只有1300多行吧！千万不要看到往下划的时候感觉很多哦！最好是去文末提取福利！先上一个图！

在这里插入图片描述

文末有福利哦

入口——“Main”类

这个类是整个流程的开始
先来说明一下这个类，首先这个其中的变量命名与项目思想是受到了网上一篇别人的思想的影响，不过网上是没有完整代码的分享与实现的！我当时搜索这个项目的时候都是一些不完整的内容。其中有一篇文章我受到了启发，里面讲将12条道路看成12个集合，然后把车添加到这些集合里面。我觉得这个思想挺好的，所以就采用了这个思想并独立的完成了这个思想的实现。
类似static List <Car>list_S2W=new ArrayList<Car>();这样的命名表示从南边到西边也可以说南边的车往左转
这个类的代码相对较少，代码里面也有注释，可以仔细理解一下哦！

import java.util.ArrayList;
import java.util.List;

public class Main {
/**********************************类(共享)变量区************************************************/
	//创建12个集合，用来分别存放每条道路上的车辆数量
		//添加总的车对象
		static List <Car>list_all=new ArrayList<Car>();
		//南边三条道路集合
		static List <Car>list_S2W=new ArrayList<Car>();
		static List <Car>list_S2N=new ArrayList<Car>();
		static List <Car>list_S2E=new ArrayList<Car>();
		//北边三条道路集合
		static List <Car>list_N2E=new ArrayList<Car>();
		static List <Car>list_N2S=new ArrayList<Car>();
		static List <Car>list_N2W=new ArrayList<Car>();
		//东边三条道路集合
		static List <Car>list_E2S=new ArrayList<Car>();
		static List <Car>list_E2W=new ArrayList<Car>();
		static List <Car>list_E2N=new ArrayList<Car>();
		//西边三条道路集合
		static List <Car>list_W2N=new ArrayList<Car>();
		static List <Car>list_W2E=new ArrayList<Car>();
		static List <Car>list_W2S=new ArrayList<Car>();
		//实例化Map的静态对象，值实例化一次，假如不使用static，则每生成一个车对象就会实例化一个Map对象
		//在这里实例化Map对象是因为方便后续的在Car类里面调用Map的repaint();
		//用static关键字修饰的变量，在类实例化对象的时候开辟一块独立的内存，实例化的每个对象都共享这块内存
		static Map map=new Map();
/**********************************类(共享)变量区************************************************/
	/**主方法，对生成车辆的数量进行控制，并启动每辆车的线程*/
	public static void main(String[] args) {
		for(int i=0;i<100;i++) {
	    Car car=new Car();
		new Thread(car).start();
		
	}
}//主方法结束
}

地图调用——“Map”类

我们顺着Main类往下，会看到这个static Map map=new Map();这条语句，那这条语句呢就是和Map类有关的啦！这个将Map(地图)对象修饰为静态的，以便后面只出现一次地图，然后所有的车都在上面跑！
这个类也不复杂，代码里面也有相应的注释

import java.awt.Color;
import javax.swing.JFrame;

/**十字路口设计图*/
@SuppressWarnings("serial")
public class Map extends JFrame{
	public Map() {//实现构造方法
			initialize();//调用初始化方法，对界面进行设计
			MyCanvas mycanvas=new MyCanvas();//调用画布类实例一个对象
			this.getContentPane().add(mycanvas);//添加画布	
			mycanvas.setSize(this.getWidth(),this.getHeight());
		 	this.setLayout(null);
		    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	    
	}//构造方法结束
	/**初始化依附的窗体*/
public void initialize() {
			this.setTitle("十字路口交通信号灯管理系统");
			this.setBounds(500, 130, 1200, 900);//设置窗体大小
			this.setBackground(new Color(147,147,147));//设置窗体背景色
			this.setVisible(true);//设置窗体可见
			this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体关闭模式
	}//初始化方法结束
}//初始化窗体方法结束

画地图——“MyCanvas”类

那顺着Map类我们也看到了 MyCanvas mycanvas=new MyCanvas();//调用画布类实例一个对象 this.getContentPane().add(mycanvas);//添加画布 mycanvas.setSize(this.getWidth(),this.getHeight());我们也看到了这三条语句
这个类的主要目的就是实现地图的细节，将具体的线条画出来，然后里面包括了灯组的控制，还有控制车的一些判断，嗯~由于代码水平低，导致我写的代码都是耦合度太高了，并不独立，现在我自己都难得看了（晕，捂脸！(*/ω＼*)）

package java交通灯;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JButton;
import javax.swing.JPanel;

/**
 * @该类主要是对地图进行设计，包括启动灯组*/
	@SuppressWarnings("serial")
public class MyCanvas extends JPanel implements ActionListener,MouseListener,MouseMotionListener{
/**********************************成员变量区***************************************************/
		JButton start=new JButton("statrt");//启动灯组的按钮
		JButton stop=new JButton("stop");//暂停灯组的按钮
		//四组灯组，之所以能够将灯组实例化放在单独灯实例化前面是因为单独灯的修饰符是static的，在类实例化之前就有了分配的内存
	 	LightControl LightControl1=new LightControl(light_N_right,light_N_middle,light_N_left,"NS",'N',10);
	 	LightControl LightControl2=new LightControl(light_S_left,light_S_middle,light_S_right,"NS",'S',10);
	 	LightControl LightControl3=new LightControl(light_E_right,light_E_middle,light_E_left,"WE",'E',20);
	 	LightControl LightControl4=new LightControl(light_W_left,light_W_middle,light_W_right,"WE",'W',20);
	 	//线程对象
			Thread f1=new Thread(LightControl1);
		 	Thread f2=new Thread(LightControl2);
		 	Thread f3=new Thread(LightControl3);
		 	Thread f4=new Thread(LightControl4);
/**********************************成员变量区***************************************************/
		
/**********************************类(共享)变量区***************************************************/
		 //十二个灯
		 //北灯
	 	static Light light_N_left=new Light(0,0,Light.light_green);
	 	static Light light_N_middle=new Light(50,0,Light.light_green);
	 	static Light light_N_right=new Light(100,0,Light.light_red);
	 	//南灯
	 	static Light light_S_left=new Light(50,0,Light.light_red);
	 	static Light light_S_middle=new Light(100,0,Light.light_green);
	 	static Light light_S_right=new Light(150,0,Light.light_green);
	 	//东灯
	 	static Light light_E_left=new Light(0,0,Light.light_green);
	 	static Light light_E_middle=new Light(0,50,Light.light_red);
	 	static Light light_E_right=new Light(0,100,Light.light_red);
	 	//西灯
	 	static Light light_W_left=new Light(0,50,Light.light_red);
	 	static Light light_W_middle=new Light(0,100,Light.light_red);
	 	static Light light_W_right=new Light(0,150,Light.light_green);
/**********************************类(共享)变量区***************************************************/
			
	 	/**构造方法*/
MyCanvas(){
	
			//添加鼠标监听是因为方便查看这个窗体的每个点的坐标
		    addMouseListener(this);
		    addMouseMotionListener(this);
			//两个按钮
			start.addActionListener(this);
			start.setBounds(30, 30, 80, 30);
			this.add(start);
			stop.addActionListener(this);
			stop.setBounds(30, 70, 80, 30);
			this.add(stop);
			//设置灯组在面板的位置
	 	 	LightControl1.setBounds(405, 305, 200,50);//N
	 	 	LightControl2.setBounds(495, 545,200,50);//S
	 	 	LightControl3.setBounds(645, 305, 50,200);//E
	 	 	LightControl4.setBounds(405, 395, 50,200);//W
	 	 	//添加四个灯组
 	 	 	this.add(LightControl1);
 	 	 	this.add(LightControl2);
 	 	 	this.add(LightControl3);
 	 	 	this.add(LightControl4);
 	 	 	
		}
	public void paint(Graphics g) {
		Graphics2D G=(Graphics2D)g;
		//--------------------设置画笔大小-----------------------
		BasicStroke bs1=new BasicStroke(3.0f);
		BasicStroke bs2=new BasicStroke(5.0f);
		BasicStroke bs3 = new BasicStroke(5.0f, BasicStroke.CAP_BUTT,BasicStroke.JOIN_ROUND, 2.0f, new float[] { 10, 10, }, 0f);
		BasicStroke bs4=new BasicStroke(5.0f);
		//中心矩形
		Rectangle2D Rectangle=new Rectangle2D.Double(400,300,300,300);
		G.setStroke(bs1);
		G.setColor(Color.WHITE);
		G.draw(Rectangle);
		//---------------------画绿色草坪-----------------------
		//前两个参数一定要是左上角位置
		G.setColor(new Color(14,84,12));
		G.fillRect(0, 0, 400, 300);
		G.fillRect(0, 600,400,300);
		G.fillRect(700,600,500,300);
		G.fillRect(700, 0, 500, 300);
		//---------------------画黄色实线------------------------
		//南黄线
		Line2D line_south1=new Line2D.Double(400, 600, 400, 900);
		Line2D line_south2=new Line2D.Double(550, 600, 550,900);
		Line2D line_south3=new Line2D.Double(700, 600, 700, 900);
		//东黄线
		Line2D line_east1=new Line2D.Double(700, 600, 1200, 600);
		Line2D line_east2=new Line2D.Double(700,450,1200,450);
		Line2D line_east3=new Line2D.Double(700, 300, 1200, 300);
		//北黄线
		Line2D line_north1=new Line2D.Double(700, 300, 700, 0);
		Line2D line_north2=new Line2D.Double(550, 300, 550, 0);
		Line2D line_north3=new Line2D.Double(400, 300, 400, 0);
		//西黄线
		Line2D line_west1=new Line2D.Double(400, 300, 0, 300);
		Line2D line_west2=new Line2D.Double(400, 450, 0, 450);
		Line2D line_west3=new Line2D.Double(400, 600, 0, 600);
		//-----------------设置画笔属性并添加黄色实现----------
		G.setStroke(bs2);
		G.setColor(Color.YELLOW);
		G.draw(line_west1);
		G.draw(line_north3);
		G.draw(line_north1);
		G.draw(line_east3);
		G.draw(line_west3);
		G.draw(line_south1);
		G.draw(line_south3);
		G.draw(line_east1);
		G.draw(line_north2);
		G.draw(line_east2);
		G.draw(line_south2);
		G.draw(line_west2);
		//------------------------画黄色虚线----------------
		Line2D dashed_line_north=new Line2D.Double(540, 300, 540, 230);
        G.setStroke(bs3);
        G.setColor(Color.yellow);
        G.draw(dashed_line_north);//北虚线
        Line2D line_north=new Line2D.Double(540, 220, 540, 0);
        G.setStroke(bs2);
        G.setColor(Color.yellow);
        G.draw(line_north);//北实线
        
		Line2D dashed_line_west=new Line2D.Double(400, 460, 330, 460);
        G.setStroke(bs3);
        G.setColor(Color.yellow);
        G.draw(dashed_line_west);//虚线2
        Line2D line_west=new Line2D.Double(320, 460, 0, 460);
        G.setStroke(bs2);
        G.setColor(Color.yellow);
        G.draw(line_west);//实线2
        
        Line2D dashed_line_south=new Line2D.Double(560, 600, 560, 670);
        G.setStroke(bs3);
        G.setColor(Color.yellow);
        G.draw(dashed_line_south);//虚线3
        Line2D line_south=new Line2D.Double(560, 680, 560, 900);
        G.setStroke(bs2);
        G.setColor(Color.yellow);
        G.draw(line_south);//实线3
        
        Line2D dashed_line_east=new Line2D.Double(700, 440, 770, 440);
        G.setStroke(bs3);
        G.setColor(Color.yellow);
        G.draw(dashed_line_east);//虚线4
        Line2D line_east=new Line2D.Double(780, 440, 1200, 440);
        G.setStroke(bs2);
        G.setColor(Color.yellow);
        G.draw(line_east);//实线4
        //-------------------------------画白线----------------
        //第一组,南白线
        Line2D line21=new Line2D.Double(450,600,450,900);
		Line2D line22=new Line2D.Double(500,600,500,900);
		Line2D line23=new Line2D.Double(600, 600, 600,900);
		Line2D line24=new Line2D.Double(650, 600, 650,900);
		G.setStroke(bs4);
		G.setColor(Color.WHITE);
		G.draw(line21);//白线1
		G.draw(line22);//白线2
		G.draw(line23);//白线3
		G.draw(line24);//白线4
		//第二组,东白线
		Line2D line25=new Line2D.Double(700,350,1200,350);
		Line2D line26=new Line2D.Double(700,400,1200,400);
		Line2D line27=new Line2D.Double(700,500,1200,500);
		Line2D line28=new Line2D.Double(700,550,1200,550);
		G.setStroke(bs4);
		G.setColor(Color.WHITE);
		G.draw(line25);//白线1
		G.draw(line26);//白线2
		G.draw(line27);//白线3
		G.draw(line28);//白线4
		//第三组，北白线
		Line2D line29=new Line2D.Double(450,300,450,0);
		Line2D line30=new Line2D.Double(500,300,500,0);
		Line2D line31=new Line2D.Double(600,300,600,0);
		Line2D line32=new Line2D.Double(650,300,650,0);
		G.setStroke(bs4);
		G.setColor(Color.WHITE);
		G.draw(line29);//白线1
		G.draw(line30);//白线2
		G.draw(line31);//白线3
		G.draw(line32);//白线4
		//第四组，西白线
		Line2D line33=new Line2D.Double(400,350,0,350);
		Line2D line34=new Line2D.Double(400,400,0,400);
		Line2D line35=new Line2D.Double(400,500,0,500);
		Line2D line36=new Line2D.Double(400,550,0,550);
		G.setStroke(bs4);
		G.setColor(Color.WHITE);
		G.draw(line33);//白线1
		G.draw(line34);//白线2
		G.draw(line35);//白线3
		G.draw(line36);//白线4
		//-------------------------写提示文字----------
		//设置字体
		Font font1=new Font("宋体",Font.BOLD,50);
		Font font2=new Font("宋体",Font.BOLD,20);
		G.setColor(Color.white);
		G.setFont(font1);
		G.drawString("十字路口", 700, 60);
		G.setFont(font2);
		G.drawString("1.左转：左转红灯停止，左转绿灯左转", 750, 100);
		G.drawString("2.直行：直行红灯停止，直行绿灯通行", 750, 140);
		G.drawString("3.右转：常绿", 750, 180);
		Toolkit toolkit=getToolkit();
	    //-------------------------第一组图片------------
	    Image img1=toolkit.getImage("src/图片/1.1.png");
	    G.drawImage(img1, 545, 625,70,130,this);
	    Image img2=toolkit.getImage("src/图片/1.2.png");
	    G.drawImage(img2, 590, 650,70,70,this);
	    Image img3=toolkit.getImage("src/图片/1.3.png");
	    G.drawImage(img3, 640, 625,70,130,this);
	    //--------------------------第二组图片-----------
	    Image img4=toolkit.getImage("src/图片/2.1.png");
	    G.drawImage(img4, 735, 385,130,70,this);
	    Image img5=toolkit.getImage("src/图片/2.2.png");
	    G.drawImage(img5, 760, 340,70,70,this);
	    Image img6=toolkit.getImage("src/图片/2.3.png");
	    G.drawImage(img6, 735, 290,130,70,this);
	    //--------------------------第三组图片-----------
	    Image img7=toolkit.getImage("src/图片/3.1.png");
	    G.drawImage(img7, 485, 140,70,130,this);
	    Image img8=toolkit.getImage("src/图片/3.2.png");
	    G.drawImage(img8, 440, 175,70,70,this);
	    Image img9=toolkit.getImage("src/图片/3.3.png");
	    G.drawImage(img9, 390, 140,70,130,this);
	    //---------------------------第四组图片----------
	    Image img10=toolkit.getImage("src/图片/4.1.png");
	    G.drawImage(img10, 240, 445,130,70,this);
	    Image img11=toolkit.getImage("src/图片/4.2.png");
	    G.drawImage(img11, 275, 490,70,70,this);
	    Image img12=toolkit.getImage("src/图片/4.3.png");
	    G.drawImage(img12, 240, 540,130,70,this);

//#####################################通过调用添加总车的集合list_all画车######################################################################
for (int j = 0; j <Main.list_all.size(); j++) { 
		if(Main.list_all.get(j).road=="S2W"||Main.list_all.get(j).road=="S2N"||
				Main.list_all.get(j).road=="S2E"||Main.list_all.get(j).road=="N2E"||
						Main.list_all.get(j).road=="N2S"||Main.list_all.get(j).road=="N2W") {
//##############################################判断南北是否左转################################################
					//这里的判断很有必要，注意boolean类型的变量的初始值是false
					if(Main.list_all.get(j).turn_right==false&&Main.list_all.get(j).turn_left==false){
						G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_width, Car.car_height, this);
					}else if(Main.list_all.get(j).turn_left==true) {
						G.rotate(Math.toRadians(-Main.list_all.get(j).rotation_angle),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
						G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_width, Car.car_height, this);
						G.rotate(Math.toRadians(Main.list_all.get(j).rotation_angle),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
					}
//##############################################判断南北是否左转################################################
					
//##############################################判断南北是否右转################################################
					//这里的判断很有必要，注意boolean类型的变量的初始值是false
					if(Main.list_all.get(j).turn_right==false&&Main.list_all.get(j).turn_left==false) {
						G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_width, Car.car_height, this);
					}else if(Main.list_all.get(j).turn_right==true) {
						G.rotate(Math.toRadians(90),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
						G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_width, Car.car_height, this);
						G.rotate(Math.toRadians(-90),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
					}
//##############################################判断南北是否右转################################################
					}//if判断结束

					else {
 //##############################################判断东西是否左转################################################
						    //这里的判断很有必要，注意boolean类型的变量的初始值是false
							if(Main.list_all.get(j).turn_right==false&&Main.list_all.get(j).turn_left==false){
								G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_height, Car.car_width, this);
							}else if(Main.list_all.get(j).turn_left==true) {
								G.rotate(Math.toRadians(-Main.list_all.get(j).rotation_angle),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
								G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_height, Car.car_width, this);
								G.rotate(Math.toRadians(Main.list_all.get(j).rotation_angle),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
								
							}
//##############################################判断东西是否左转################################################
							
//##############################################判断东西是否右转################################################
							//这里的判断很有必要，注意boolean类型的变量的初始值是false
							if(Main.list_all.get(j).turn_right==false&&Main.list_all.get(j).turn_left==false) {
								//这条语句总是会抛出异常，得查看下
								G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_height, Car.car_width, this);
						    }else if(Main.list_all.get(j).turn_right==true) {
						    	G.rotate(Math.toRadians(90),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
								G.drawImage(getToolkit().getImage(Main.list_all.get(j).car_img), Main.list_all.get(j).x1, Main.list_all.get(j).y1, Car.car_height, Car.car_width, this);
								G.rotate(Math.toRadians(-90),Main.list_all.get(j).x1,Main.list_all.get(j).y1);
						    }
					}
//##############################################判断东西是否右转################################################
	
	}//for循环结束
	}//paint()结束
	@Override
	public void actionPerformed(ActionEvent e) {
		if(e.getSource()==start) {
			//启动四组灯
			LightControl.RUN=true;
		 	f1.start();
		 	f2.start();
		 	f3.start();
		 	f4.start();
		 	
		}
		else if(e.getSource()==stop)
	 	{
			LightControl.RUN=false;
	 	}
		
	}//actionPerformed方法结束

	@Override
	public void mouseClicked(java.awt.event.MouseEvent e) {	
		System.out.println("x:"+e.getX()+","+"y:"+e.getY());
	}
	@Override
	public void mousePressed(java.awt.event.MouseEvent e) {	
		
	}
	@Override
	public void mouseReleased(java.awt.event.MouseEvent e) {
	
	}
	@Override
	public void mouseEntered(java.awt.event.MouseEvent e) {	
	}
	@Override
	public void mouseExited(java.awt.event.MouseEvent e) {	
	}
	@Override
	public void mouseDragged(java.awt.event.MouseEvent e) {
	}
	@Override
	public void mouseMoved(java.awt.event.MouseEvent e) {
}
	}

这里面加了鼠标监听，主要是想要通过鼠标点击这个画布来实现位置的确认，以便进行后续车辆行驶时的定位操作将就看下吧！说实话我自己都看不下去了（不要喷我啊！）我在考虑还要不要拿出来了，我估计拿出来都很少有人去看，而且能捋清这个思路… …！

灯——“Light”类

嗯，经过了30min慎重的思考，我决定还是拿出来吧！反正已经写了一大半了，不能中途放弃是吧！在上面那个类中呢，包含了灯（Light）类，然后车（Car）类
灯类都很简单，主要是灯的这个类的定义，很简短

public class Light {
	/**灯颜色常量——黄色*/
	public static final int light_yellow=0;
	/**灯颜色常量——红色*/
	public static final int light_red=1;
	/**灯颜色常量——绿色*/
	public static final int light_green=2;
	/**存放灯图片的路径数组 0-黄，1-红，2-绿*/
	String light_img[]= {"src/图片/黄.png","src/图片/红.png","src/图片/绿.png"};
	/**灯在面板的位置*/
  	int x,y;
  	/**灯的状态，三种(0-黄，1-红，2-绿)*/
  	int status;
/**对内初始化时设置的灯的状态*/
public Light(int x,int y,int status) {
  		this.x=x;                
  		this.y=y;
  		this.status=status;
}
/**得到红绿灯图片*/
public String getphoto() {
	return this.light_img[status];
}//getphoto()结束
/**对外得到灯的状态*/
public int get_status() {
	return this.status;
}

}

灯控制类——“LightControl”类

这个类的作用就是控制灯的运作，也就是红黄绿三状态的切换，使用了java线程。

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;

/**对灯组进行智能化控制的类*/
@SuppressWarnings("serial")
public class LightControl extends Canvas implements Runnable {
//**********************************类(共享)变量区***********************************************
	 /**控制灯的线程运行的boolean变量*/
	 public static boolean RUN=true;
	 /**单个灯的宽度*/
	 private static final int light_width=50;
	 /**单个灯的高度*/
	 private static final int light_height=50;
	 /**对计时牌的重画限制时间*/
	 private static final int repaint_time=500;
//**********************************类(共享)变量区***********************************************
	
//**********************************成员变量区***************************************************
	/**每一组灯组的时间*/
	 private int time;
	 /**对灯组的选择*/
	 private String Lampgroup_choice;
	 /**灯的选择,比如中间的灯或者左边的灯*/
	 private char light_choice;
	 /**灯-左，灯-中，灯-右*/
	 private Light  light_left, light_middle,light_right;
 //**********************************成员变量区***************************************************
	 
	 /**@1、传入一组灯，按左、中、右顺序，对每组灯进行相应的控制
	  * @2、给定灯的时间
	  * @3、对灯组的选择（南北、东西）*/
public LightControl(Light light_left,Light light_middle,Light light_right,String Lampgroup_choice,char light_choice,int time) {
	this.light_left=light_left;
	this.light_middle=light_middle;
	this.light_right=light_right;
	this.light_choice=light_choice;
	this.Lampgroup_choice=Lampgroup_choice;
	this.time=time;	
}//Light_control()结束
	/**@画南北灯*/
public void paint_NS_Light_control(Graphics2D G) {
	G.drawImage(getToolkit().getImage(light_left.getphoto()), light_left.x,light_left.y,light_width,light_height,this);
    G.drawImage(getToolkit().getImage(light_middle.getphoto()), light_middle.x,light_middle.y,light_width,light_height,this);
    G.drawImage(getToolkit().getImage(light_right.getphoto()), light_right.x,light_right.y,light_width,light_height,this);
    G.setColor(Color.BLACK);
}//画南北灯的方法结束
	/**@画东西灯*/
public void paint_WE_Light_control(Graphics2D G) {
	G.drawImage(getToolkit().getImage(light_left.getphoto()), light_left.x,light_left.y,light_width,light_height,this);
    G.drawImage(getToolkit().getImage(light_middle.getphoto()), light_middle.x,light_middle.y,light_width,light_height,this);
    G.drawImage(getToolkit().getImage(light_right.getphoto()), light_right.x,light_right.y,light_width,light_height,this);
    G.setColor(Color.BLACK);
}//画东西灯的方法结束
	/**重写paint()方法*/
public void paint(Graphics g) {
	Graphics2D G=(Graphics2D)g;
	switch(this.light_choice) {
case 'N':
		paint_NS_Light_control(G);//调用画南北灯的的方法
		//画北计时板
	    G.fillRect(light_left.x+52, light_left.y, light_width, light_height);
	    G.setColor(Color.RED);
	    G.setFont(new Font("宋体",Font.BOLD,40));
	    G.drawString(time+" ", light_left.x+52,light_left.y+40 );
	break;
case 'S':
		paint_NS_Light_control(G);//调用画南北灯的的方法
		//画南计时板
	    G.fillRect(light_left.x-52, light_left.y, light_width, light_height);
	    G.setColor(Color.RED);
	    G.setFont(new Font("宋体",Font.BOLD,40));
	    G.drawString(time+" ", light_left.x-52,light_left.y+40 );
	break;
case 'E':
		paint_WE_Light_control(G);//调用画东西灯的的方法	 
		//画东计时板
		G.fillRect(light_left.x, light_left.y+52, light_width, light_height);
	    G.setColor(Color.RED);
	    G.setFont(new Font("宋体",Font.BOLD,40));
	    G.drawString(time+" ", light_left.x,light_left.y+90 );
	break;
case 'W':
		paint_WE_Light_control(G);//调用画东西灯的的方法
		//画西计时板
	    G.fillRect(light_left.x, light_left.y-52, light_width, light_height);
	    G.setColor(Color.RED);
	    G.setFont(new Font("宋体",Font.BOLD,40));
	    G.drawString(time+" ", light_left.x,light_left.y-10 );
	break;
	
	}
}//paint()结束
	/**@对每组灯进行相应控制的具体操作
	 * @这里使用嵌套switch*/
@Override
public void run() {
	String light_choice1="light_middle";//对灯的选择，左中右三种
	String light_choice2="stop";
	while(RUN) {
		switch(Lampgroup_choice) {//由实例化时给定的参数决定
		case "NS":
			switch(light_choice1) {//先让北和南部中间灯显示绿灯
			case "light_middle":
			{
				try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
				repaint();
				this.time--;
				if(this.time>3) {
				light_left.status=Light.light_red;//红
				light_middle.status=Light.light_green;//绿
				
				}
				if(this.time<=3&&this.time>0) {
					light_left.status=Light.light_yellow;//黄
					light_middle.status=Light.light_yellow;//黄
				}
				if(time==0) {
					this.time=10;
					light_left.status=Light.light_green;//绿
					light_middle.status=Light.light_red;//红
					light_choice1="light_left";
				}
			}
				break;
			case "light_left"://然后北和南部左边灯显示绿灯
			{
				try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
				repaint();
				this.time--;
				if(time>3) {
				light_left.status=Light.light_green;//绿
				light_middle.status=Light.light_red;//红
				
				}
				if(time>0&&time<=3) {
					light_left.status=Light.light_yellow;//黄
					light_middle.status=Light.light_red;//继续为红已改
				}
				if(time==0) {
					this.time=20;
					light_left.status=Light.light_red;//红
					light_middle.status=Light.light_red;//红
					light_choice1="stop";
				}
			}
				break;
			case "stop":
			{   
				try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
				repaint();
				this.time--;
				if(time>0&&time<=3) {
					light_left.status=Light.light_red;//继续为红已改
					light_middle.status=Light.light_yellow;//黄
				}
				if(this.time==0) {
					time=10;
					light_left.status=Light.light_red;//红
					light_middle.status=Light.light_green;//绿
					light_choice1="light_middle";
					
				}
			}
			break;
			}//light switch语句结束
			break;
		case "WE":
				switch(light_choice2) {
				case "light_middle":
				{
					try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
					repaint();
					this.time--;
					if(this.time>3) {
					light_left.status=Light.light_red;//红
					light_middle.status=Light.light_green;//绿
					
					}
					if(this.time<=3&&this.time>0) {
						light_left.status=Light.light_yellow;//黄
						light_middle.status=Light.light_yellow;//黄
					}
					if(this.time==0) {
						this.time=10;
						light_left.status=Light.light_green;//绿
						light_middle.status=Light.light_red;//红
						light_choice2="light_left";
					}
				}
					break;
				case "light_left":
				{
					try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
					repaint();
					this.time--;
					if(time>3) {
					light_left.status=Light.light_green;//绿
					light_middle.status=Light.light_red;//红
					
					}
					if(time>0&&time<=3) {
						light_left.status=Light.light_yellow;//黄
						light_middle.status=Light.light_red;//继续为红已改
					}
					if(time==0) {
						this.time=20;
						light_left.status=Light.light_red;//红
						light_middle.status=Light.light_red;//红
						light_choice2="stop";
					}
				}
					break;
				case "stop":
				{   
					try {Thread.sleep(repaint_time);}catch(InterruptedException e) {e.printStackTrace();}
					repaint();
					this.time--;
					if(this.time>3) {
						light_left.status=Light.light_red;//红
						light_middle.status=Light.light_red;//红
						
					}
					if(time>0&&time<=3) {
						light_left.status=Light.light_red;//继续为红已改
						light_middle.status=Light.light_yellow;//黄
					}
					if(this.time==0) {
						time=10;
						light_left.status=Light.light_red;//红
						light_middle.status=Light.light_green;//绿
						light_choice2="light_middle";
						
					}
				}
				break;
				}//light switch语句结束
				break;
		}//Light_control switch语句结束
		}//while循环结束
		
	}//run()方法结束	
}

我去，我在写的时候真的有点纠结！我觉得这么多的代码弄出来应该不好吧！是有点担忧有人看到了就被吓跑了！其实呢代码也不是很多的！

最后一个车类啦——“Car”类

算了继续吧！反正最后一个类了，这个车（Car）类呢主要是给生成的每一辆车进行属性的填充，也就是随机生成的车去决定它是哪条道路上面的，然后该道路的路线指定还有车的状态等

package java交通灯;
/**对车进行智能化控制的类*/
public class Car implements Runnable{
/**********************************成员变量区***************************************************/
	int x1,y1;//车的起始位置
	int x2,y2;//车的终点位置
	int velocity;//车的速度
	int random_R;//路名随机数
	int random_V;//速度随机数
	int safety_line;//车辆等红绿灯时的安全线 
	boolean turn_left;
	boolean turn_right;//注意boolean类型的变量的初始值是false
	private boolean isAlive=true;
	String car_img;//车自身图片
	String road;//对路名的选择
	int rotation_angle;//转弯车辆的旋转角度
/**********************************成员变量区***************************************************/
	
/**********************************类(共享)变量区***********************************************/
	static  final int car_width=30;//车的宽度
	static  final int car_height=70;//车的高度
	private static  int car_U=0;//上
	private static  int car_D=1;//下
	private static  int car_L=2;//左
	private static  int car_R=3;//右
	private static  final int time=100;//小车刷新的时间
	static int car_velocity[]= {10,15,20};//车辆速度
	/**车辆图片路径数组，0-上，1-下，2-左，3-右*/
	private static String img[][]= {{"src/图片/S2N.png","src/图片/S2N2.png"},{"src/图片/N2S.png","src/图片/N2S2.png"},{"src/图片/E2W.png","src/图片/E2W2.png"},{"src/图片/W2E.png","src/图片/W2E2.png"}};
	/**路名数组*/
	private static String car_on_road[]= {"S2W","S2N","S2E","N2E","N2S","N2W","E2S","E2W","E2N","W2N","W2E","W2S"};
/**********************************类(共享)变量区************************************************/
	
	/**构造方法，对生成车各个属性的方法进行调用*/
	public Car(){
		create_car();//调用生成车属性的方法
}//构造方法结束
	/**@生成车的属性的方法
	 * @1、车辆图片
	 * @2、车辆起始位置和终点位置*/
	public void create_car() {
		//每隔5*Car.time毫秒产生一辆车
		try {Thread.sleep((int)(15*Car.time));}catch(Throwable e) {e.printStackTrace();}
		//生成随机数
		this.random_R=(int) (Math.random()*12);//随机数的范围是0~乘以的数字的前闭后开区间
		this.random_V=(int) (Math.random()*3);
		this.road=Car.car_on_road[this.random_R];//车所在道路的选择  
		this.velocity=Car.car_velocity[this.random_V];//车的速度的选择
		Main.list_all.add(this);//使用集合list_all来添加以便于后续操作全部车的对象
		switch(this.road) {
		case "S2W"://南左转西
			this.car_img=img[Car.car_U][(int) (Math.random()*2)];
			x1=565;y1=950;x2=-50;y2=430;
			this.safety_line=600;//设置行驶安全线为y1=600;
			Main.list_S2W.add(this);
			break;
		case "S2N"://南直走北
			this.car_img=img[Car.car_U][(int) (Math.random()*2)];
			x1=610;y1=950;x2=620;y2=-50;
			this.safety_line=600;//设置行驶安全线为y1=600;
			Main.list_S2N.add(this);
			 break;
		case "S2E"://南右转东
			this.car_img=img[Car.car_U][(int) (Math.random()*2)];
			x1=660;y1=950;x2=1250;y2=430;
			this.safety_line=600;//设置行驶安全线为y1=600;
			Main.list_S2E.add(this);
			 break;
		case "N2E"://北左转东
			this.car_img=img[Car.car_D][(int) (Math.random()*2)];
			x1=505;y1=-50;x2=1250;y2=470;
			this.safety_line=300;//设置行驶安全线为y1=300;
			Main.list_N2E.add(this);
			 break;
		case "N2S"://北直走南
			this.car_img=img[Car.car_D][(int) (Math.random()*2)];
			x1=460;y1=-50;x2=480;y2=950;
			this.safety_line=300;//设置行驶安全线为y1=300;
			Main.list_N2S.add(this);
			 break;
		case "N2W"://北右转西
			this.car_img=img[Car.car_D][(int) (Math.random()*2)];
			x1=410;y1=-50;x2=-50;y2=330;
			this.safety_line=300;//设置行驶安全线为y1=300;
			Main.list_N2W.add(this);
			 break;
		case "E2S"://东左转南
			this.car_img=img[Car.car_L][(int) (Math.random()*2)];
			x1=1250;y1=405;x2=520;y2=950;
			this.safety_line=700;//设置行驶安全线为x1=700
			Main.list_E2S.add(this);
			 break;
		case "E2W"://东直走西
			this.car_img=img[Car.car_L][(int) (Math.random()*2)];
			x1=1250;y1=360;x2=-50;y2=400;	
			this.safety_line=700;//设置行驶安全线为x1=700
			Main.list_E2W.add(this);
			 break;
		case "E2N"://东右转北
			this.car_img=img[Car.car_L][(int) (Math.random()*2)];
			x1=1250;y1=310;x2=670;y2=-50;
			this.safety_line=700;//设置行驶安全线为x1=700
			Main.list_E2N.add(this);
			 break;
		case "W2N"://西左转北
			this.car_img=img[Car.car_R][(int) (Math.random()*2)];
			x1=-50;y1=465;x2=570;y2=-50;
			this.safety_line=400;//设置行驶安全线为x1=400
			Main.list_W2N.add(this);
			 break;
		case "W2E"://西直走东
			this.car_img=img[Car.car_R][(int) (Math.random()*2)];
			x1=-50;y1=510;x2=1250;y2=550;	
			this.safety_line=400;//设置行驶安全线为x1=400
			Main.list_W2E.add(this);
			 break;
		case "W2S"://西右转南
			this.car_img=img[Car.car_R][(int) (Math.random()*2)];
			x1=-50;y1=560;x2=600;y2=950;
			this.safety_line=400;//设置行驶安全线为x1=400
			Main.list_W2S.add(this);
			 break;
		}//switch语句结束
}//生成车属性的方法结束
	@Override
	public void run() {
		while(this.isAlive) {
/*******************************局部变量区***********************************************/
			int original_V=this.velocity;//用变量来保存初始速度
			//之所以申请局部变量是因为要保存的是this.velocity实例化后的得到的值
			int myself;//定义一个变量来保存this(自己)在集合中的位置
			boolean isrun;//定义一个boolean变量来作为是否判断灯状态
			//设置这个变量的目的是是避免在车辆停止的时候进入判断灯的死循环，从而使电脑CPU的过载
/*******************************局部变量区***********************************************/	
			switch(this.road) {
			case "S2W"://南左转西
				while(this.x1>=this.x2) {
							try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
							Main.map.repaint();
						if(this.y1>=this.safety_line-20) {
								isrun=true;
								this.y1-=this.velocity;
//**************************************判断左转****************************************************
							    this.turn_left=false;
//**************************************判断左转****************************************************
		        		 		 
//##############################################判断红绿灯#################################################
		    		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
		        		 		while(isrun) {
				        		 if((MyCanvas.light_S_left.get_status()==Light.light_red||MyCanvas.light_S_left.get_status()==Light.light_yellow)&&(this.y1<=this.safety_line+50&&this.y1>this.safety_line)) {
				        			 this.velocity=5;
				        		 }
				        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
		         				  if((MyCanvas.light_S_left.get_status()==Light.light_red)&&(this.y1<=this.safety_line+30&&this.y1>this.safety_line)) {
		         					  	this.velocity=0;
		         				  } 
		         				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
				        		  if(this.y1<=this.safety_line) {
				        			  	this.velocity=original_V;
				        		  }
		         				 isrun=false;
				        		  }//while循环 
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
				        		  for(int i=0;i<Main.list_S2W.size();i++) {
				   		        	 if((Main.list_S2W.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_S2W.get(i).hashCode())) {
				   		        		 myself=i;//找到自己在集合中的位置
				   		        		if((Main.list_S2W.get(myself-1).y1>=this.safety_line-160)&&(Main.list_S2W.get(myself).y1-(Main.list_S2W.get(myself-1).y1+Car.car_height)<=15)) {//
				   		        			Main.list_S2W.get(myself).velocity=Main.list_S2W.get(myself-1).velocity;
				   		        			Main.list_S2W.get(myself).y1=Main.list_S2W.get(myself-1).y1+car_height+10;
				   		        		}
				   		        		else if(Main.list_S2W.get(myself).y1<this.safety_line-160){
				   		        			Main.list_S2W.get(myself).velocity=Main.list_S2W.get(myself-1).velocity;
				   	   		        		Main.list_S2W.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的
				   		        		}
				   		        	 }
				        		  } //for循环
//**************************************判断车间距****************************************************
		        	 }
		        	 else {
		        		 	this.turn_left=true;
//########################转弯时控制角度的变化########################################	
		        		 if(this.y1>this.safety_line-160) {//y=440
		        			 this.rotation_angle+=7;//角度自增
		        			 this.y1-=this.velocity;
		        		 }else if(this.y1<=this.safety_line-160) {
		        			 this.rotation_angle=90;
		        		 }
//########################转弯时控制角度的变化######################################## 
		        		 this.x1-=this.velocity;
		        		 if(this.x1<this.x2) {
		        			 Main.list_S2W.remove(this);
		        			 Main.list_all.remove(this);
		        			 isAlive=false;
		        		 }
		        	 }//if语句
	
				}//while语句 
				
			break; 
			case "S2N"://南直走北; 
				while(this.y1>=this.y2) {
	            	try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            	Main.map.repaint();
	            	isrun=true;
	            	this.y1-=this.velocity;
//##############################################判断红绿灯#################################################
		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
   		 		while(isrun) {
	        		 if((MyCanvas.light_S_middle.get_status()==Light.light_red||MyCanvas.light_S_middle.get_status()==Light.light_yellow)&&(this.y1<=this.safety_line+50&&this.y1>this.safety_line)) {
	        			 this.velocity=5;
	        		 }
	        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
    				  if((MyCanvas.light_S_middle.get_status()==Light.light_red)&&(this.y1<=this.safety_line+30&&this.y1>this.safety_line)) {
    					  	this.velocity=0;
    				  } 
    				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
	        		  if(this.y1<=this.safety_line) {
	        			  	this.velocity=original_V;
	        		  }
    				 isrun=false;
	        		  }//while循环 
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_S2N.size();i++) {
	   		        	 if((Main.list_S2N.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_S2N.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((this.y1>=this.y2)&&(Main.list_S2N.get(myself).y1-(Main.list_S2N.get(myself-1).y1+Car.car_height)<=20)) {
	   		        			Main.list_S2N.get(myself).velocity=Main.list_S2N.get(myself-1).velocity;
	   		        			Main.list_S2N.get(myself).y1=Main.list_S2N.get(myself-1).y1+car_height+10;
	   		        		}

	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
	        		  if(this.y1<this.y2){
	        			  Main.list_S2N.remove(this);
	        			  Main.list_all.remove(this);
	        			  this.isAlive=false;
	            }//if判断结束
	            }//while循环结束
			break;
			case "S2E"://南右转东
				 while(this.x1<=this.x2) {
	            		try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            		Main.map.repaint();
	            		if(this.y1>=570) {
	            			this.y1-=this.velocity;
//**************************************判断右转****************************************************
						    this.turn_right=false;
//**************************************判断右转****************************************************
//**************************************判断车间距****************************************************
	   	        		  for(int i=0;i<Main.list_S2E.size();i++) {
	   	   		        	 if((Main.list_S2E.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_S2E.get(i).hashCode())) {
	   	   		        		 myself=i;
	   	   		        		if((Main.list_S2E.get(myself-1).y1>=570)&&(Main.list_S2E.get(myself).y1-(Main.list_S2E.get(myself-1).y1+Car.car_height)<=20)) {
	   	   		        		Main.list_S2E.get(myself).y1=Main.list_S2E.get(myself-1).y1+car_height+10;
	   	   		        		}
	   	   		        		else if(Main.list_S2E.get(myself).y1<570){
	   	   		        		Main.list_S2E.get(myself).velocity=Main.list_S2E.get(myself-1).velocity;
	   	   		        		Main.list_S2E.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的
	   	   		        		}
	   	   		        	 }
	   	        		  } //for循环
//**************************************判断车间距****************************************************
	            		}
	            		else {
	            			//右旋转90度，未写
	            			this.turn_right=true;
			        		 this.x1+=this.velocity;
			        		 if(this.x1>=this.x2) {
			        			 Main.list_S2E.remove(this);
			        			 Main.list_all.remove(this);
			        			 this.isAlive=false;
			        		 }
			        	
			        	 }//if语句
				 }//while循环
				
			break;
			case "N2E"://北左转东;
				 while(this.x1<=this.x2) {
		        	 try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
		        	 	Main.map.repaint();
		        if(this.y1<=this.safety_line) {
		        	 isrun=true;
         			 this.y1+=this.velocity;
//**************************************判断左转****************************************************
					    this.turn_left=false;
//**************************************判断左转****************************************************
//##############################################判断红绿灯#################################################
		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
         			 while(isrun) {
	        		  if((MyCanvas.light_N_right.get_status()==Light.light_red||MyCanvas.light_N_right.get_status()==Light.light_yellow)&&(this.y1<this.safety_line&&this.y1>=this.safety_line-130)) {
	        		 		this.velocity=5;
         			 }
	        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
     				  if((MyCanvas.light_N_right.get_status()==Light.light_red)&&(this.y1<this.safety_line&&this.y1>=this.safety_line-100)) {
     					  	this.velocity=0;
     				  } 
     				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
	        		  if((this.y1>=this.safety_line)) {
	        			  	this.velocity=original_V;
	        		  }
	        		  isrun=false;
	        		  }//while循环
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_N2E.size();i++) {
	   		        	 if((Main.list_N2E.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_N2E.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((Main.list_N2E.get(myself-1).y1<=this.safety_line+180)&&(Main.list_N2E.get(myself-1).y1-(Main.list_N2E.get(myself).y1+Car.car_height)<=20)) {
	   		        			Main.list_N2E.get(myself).velocity=Main.list_N2E.get(myself-1).velocity;
	   		        			Main.list_N2E.get(myself).y1=Main.list_N2E.get(myself-1).y1-(car_height+10);
	   		        		}
	   		        		else if(Main.list_N2E.get(myself).y1>this.safety_line+180){
	   		        			Main.list_N2E.get(myself).velocity=Main.list_N2E.get(myself-1).velocity;
	   	   		        		Main.list_N2E.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的

	   		        		}
	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
		        	 }
		        	 else {
		        		 	this.turn_left=true;
//########################转弯时控制角度的变化########################################	
			        		 if(this.y1<this.safety_line+180) {
			        			 this.rotation_angle+=5;
			        			 this.y1+=this.velocity;
			        		 }else if(this.y1>=this.safety_line+180) {
			        			 this.rotation_angle=90;
			        		 }
//########################转弯时控制角度的变化######################################## 
		        		 	this.x1+=this.velocity;
		        		 if(this.x1>=this.x2) {
		        			 Main.list_N2E.remove(this);
		        			 Main.list_all.remove(this);
		        			 this.isAlive=false;
		        		 }
		        	 }//if语句
	
		       }//while语句	
			break;
			case "N2S"://北直走南;
				while(this.y1<=this.y2) {
	            	try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            		Main.map.repaint(); 
	            		isrun=true;
	            		this.y1+=this.velocity;
//##############################################判断红绿灯#################################################
			 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
	         			 while(isrun) {
		        		  if((MyCanvas.light_N_middle.get_status()==Light.light_red||MyCanvas.light_N_middle.get_status()==Light.light_yellow)&&(this.y1<this.safety_line&&this.y1>=this.safety_line-130)) {
		        		 		this.velocity=5;
	         			 }
		        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
	     				  if((MyCanvas.light_N_middle.get_status()==Light.light_red)&&(this.y1<this.safety_line&&this.y1>=this.safety_line-100)) {
	     					  	this.velocity=0;
	     				  } 
	     				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
		        		  if((this.y1>=this.safety_line)) {
		        			  	this.velocity=original_V;
		        		  }
		        		  isrun=false;
		        		  }//while循环
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_N2S.size();i++) {
	   		        	 if((Main.list_N2S.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_N2S.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((this.y1<=this.y2)&&(Main.list_N2S.get(myself-1).y1-(Main.list_N2S.get(myself).y1+Car.car_height)<=20)) {
	   		        			Main.list_N2S.get(myself).velocity=Main.list_N2S.get(myself-1).velocity;
	   		        			Main.list_N2S.get(myself).y1=Main.list_N2S.get(myself-1).y1-(car_height+10);
	   		        		}

	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
	            if(this.y1>=this.y2) {
	            	Main.list_N2S.remove(this);
	            	Main.list_all.remove(this);
	            	this.isAlive=false;
	            }//if判断结束
	            }//while循环结束
			break;
			case "N2W"://北右转西;
				 while(this.x1>=this.x2) {
	            		try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            		Main.map.repaint();
	            		if(this.y1<=this.safety_line) {
	            			this.y1+=this.velocity;
//**************************************判断左转****************************************************
						    this.turn_right=false;
//**************************************判断左转****************************************************
//**************************************判断车间距****************************************************
		   	        		  for(int i=0;i<Main.list_N2W.size();i++) {
		   	   		        	 if((Main.list_N2W.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_N2W.get(i).hashCode())) {
		   	   		        		 myself=i;
		   	   		        		if((Main.list_N2W.get(myself-1).y1<=this.safety_line)&&(Main.list_N2W.get(myself-1).y1-(Main.list_N2W.get(myself).y1+Car.car_height)<=20)) {
		   	   		        			Main.list_N2W.get(myself).velocity=Main.list_N2W.get(myself-1).velocity;
		   	   		        			Main.list_N2W.get(myself).y1=Main.list_N2W.get(myself-1).y1-(car_height+10);
		   	   		        		}
		   	   		        		else if(Main.list_N2W.get(myself).y1>this.safety_line){
		   	   		        			Main.list_N2W.get(myself).velocity=Main.list_N2W.get(myself-1).velocity;
		   	   		        			Main.list_N2W.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的
		   	   		        		}
		   	   		        	 }
		   	        		  } //for循环
//**************************************判断车间距****************************************************
	            		}
	            		else {
	            			 this.turn_right=true;
			        		 this.x1-=this.velocity;
			        		 if(this.x1<=this.x2) {
			        			 Main.list_N2W.remove(this);
			        			 Main.list_all.remove(this);
			        			 this.isAlive=false;
			        		 }
			        		
			        	 }//if语句
				 }//while循环
				
			break;
			case "E2S"://东左转南 
				 while(this.y1<=this.y2) {
		        	 try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
		        	 Main.map.repaint();
		        	 if(this.x1>=this.safety_line-20) {
		        	 isrun=true;
         			 this.x1-=this.velocity;
//**************************************判断左转****************************************************
					    this.turn_left=false;
//**************************************判断左转****************************************************
//##############################################判断红绿灯#################################################
		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
         			 while(isrun) {
	        		 if((MyCanvas.light_E_right.get_status()==Light.light_red||MyCanvas.light_E_right.get_status()==Light.light_yellow)&&(this.x1<=this.safety_line+90&&this.x1>this.safety_line)) {
	        		 		this.velocity=5;
	        		  }
	        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
     				  if((MyCanvas.light_E_right.get_status()==Light.light_red)&&(this.x1>this.safety_line&&this.x1<this.safety_line+60)) {
     					  	this.velocity=0;
     				  
     				  } 
     				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
	        		  if((this.x1<=this.safety_line)) {
	        			  	this.velocity=original_V;
	        		  }
	        		  isrun=false;
	        		  }//while循环
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_E2S.size();i++) {
	   		        	 if((Main.list_E2S.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_E2S.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((Main.list_E2S.get(myself-1).x1>=500)&&(Main.list_E2S.get(myself).x1-(Main.list_E2S.get(myself-1).x1+Car.car_height)<=20)) {
	   		        			Main.list_E2S.get(myself).velocity=Main.list_E2S.get(myself-1).velocity;
	   		        			Main.list_E2S.get(myself).x1=Main.list_E2S.get(myself-1).x1+(car_height+10);
	   		        		}
	   		        		else if(Main.list_E2S.get(myself).x1<500){
	   		        			Main.list_E2S.get(myself).velocity=Main.list_E2S.get(myself-1).velocity;
	   	   		        		Main.list_E2S.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的

	   		        		}
	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
		        	 }
		        	 else {
		        		 
		        		 this.turn_left=true;
//########################转弯时控制角度的变化########################################	
		        		 if(this.x1>510) {
		        			 this.rotation_angle+=5;
		        			 this.x1-=this.velocity;
		        		 }else if(this.x1<=510) {
		        			 this.rotation_angle=90;
		        		 }
//########################转弯时控制角度的变化######################################## 
		        		 this.y1+=this.velocity;
		        		 if(this.y1>this.y2) {
		        			 Main.list_E2S.remove(this);
		        			 Main.list_all.remove(this);
		        			 this.isAlive=false;
		        		 }
		        	 }//if语句
	
		       }//while语句	
			break;
			case "E2W"://东直走西;
				while(this.x1>=this.x2) {
	            	try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            		Main.map.repaint();
	            		isrun=true;
	            		this.x1-=this.velocity;
//##############################################判断红绿灯#################################################
			 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
	         			 while(isrun) {
		        		 if((MyCanvas.light_E_middle.get_status()==Light.light_red||MyCanvas.light_E_middle.get_status()==Light.light_yellow)&&(this.x1<=this.safety_line+90&&this.x1>this.safety_line)) {
		        		 		this.velocity=5;
		        		  }
		        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
	     				  if((MyCanvas.light_E_middle.get_status()==Light.light_red)&&(this.x1>this.safety_line&&this.x1<this.safety_line+60)) {
	     					  	this.velocity=0;
	     				  
	     				  } 
	     				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
		        		  if((this.x1<=this.safety_line)) {
		        			  	this.velocity=original_V;
		        		  }
		        		  isrun=false;
		        		  }//while循环
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_E2W.size();i++) {
	   		        	 if((Main.list_E2W.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_E2W.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((this.x1>=this.x2)&&(Main.list_E2W.get(myself).x1-(Main.list_E2W.get(myself-1).x1+Car.car_height)<=20)) {
	   		        			Main.list_E2W.get(myself).velocity=Main.list_E2W.get(myself-1).velocity;
	   		        			Main.list_E2W.get(myself).x1=Main.list_E2W.get(myself-1).x1+(car_height+10);
	   		        		}

	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
	            if(this.x1<this.x2) {
	            		Main.list_E2W.remove(this);
	            		Main.list_all.remove(this);
	            		this.isAlive=false;
	            }//if判断结束
	            }//while循环结束
			break;
			case "E2N"://东右转北
				while(this.y1>=this.y2) {
            		try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
            		Main.map.repaint();
            		if(this.x1>=700) {
            			this.x1-=this.velocity;
//**************************************判断右转****************************************************
					    this.turn_right=false;
//**************************************判断右转****************************************************
//**************************************判断车间距****************************************************
  	        		  for(int i=0;i<Main.list_E2N.size();i++) {
  	   		        	 if((Main.list_E2N.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_E2N.get(i).hashCode())) {
  	   		        		 myself=i;
  	   		        		if((Main.list_E2N.get(myself-1).x1>=700)&&(Main.list_E2N.get(myself).x1-(Main.list_E2N.get(myself-1).x1+Car.car_height)<=20)) {
  	   		        			Main.list_E2N.get(myself).velocity=Main.list_E2N.get(myself-1).velocity;
  	   		        			Main.list_E2N.get(myself).x1=Main.list_E2N.get(myself-1).x1+(car_height+10);
  	   		        		}
  	   		        		else if(Main.list_E2N.get(myself).x1<700){
  	   		        			Main.list_E2N.get(myself).velocity=Main.list_E2N.get(myself-1).velocity;
  	   		        			Main.list_E2N.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的
  	   		        		}
  	   		        	 }
  	        		  } //for循环
//**************************************判断车间距****************************************************
            		}
            		else {
		        		 //右旋转90度，未写
            			 this.turn_right=true;
		        		 this.y1-=this.velocity;
		        		if(this.y1<this.y2) {
		        			 Main.list_E2N.remove(this);
		        			 Main.list_all.remove(this);
		        			 this.isAlive=false;
		        		 }
		        	 }//if语句
			 }//while循环
			
			break;
			case "W2N"://西左转北 ;
				 while(this.y1>=this.y2) {
		        	 try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
		        	 Main.map.repaint();
		        	 if(this.x1<=this.safety_line+20) {
		        	 isrun=true;
         			 this.x1+=this.velocity;
//**************************************判断右转****************************************************
					    this.turn_left=false;
//**************************************判断右转****************************************************
//##############################################判断红绿灯#################################################
		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
         			 while(isrun) {
	        		  if((MyCanvas.light_W_left.get_status()==Light.light_red||MyCanvas.light_W_left.get_status()==Light.light_yellow)&&(this.x1>=this.safety_line-130&&this.x1<this.safety_line)) {
	        		 		this.velocity=5;
	        		  }
	        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
     				  if((MyCanvas.light_W_left.get_status()==Light.light_red)&&(this.x1<this.safety_line&&this.x1>=this.safety_line-100)) {
     					  	this.velocity=0;
     				  
     				  } 
     				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
	        		  if((this.x1>=this.safety_line)) {
	        			  	this.velocity=original_V;
	        		  }
	        		  isrun=false;
	        		  } //while循环 
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_W2N.size();i++) {
	   		        	 if((Main.list_W2N.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_W2N.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((Main.list_W2N.get(myself-1).x1<=530)&&(Main.list_W2N.get(myself-1).x1-(Main.list_W2N.get(myself).x1+Car.car_height)<=20)) {
	   		        			Main.list_W2N.get(myself).velocity=Main.list_W2N.get(myself-1).velocity;
	   		        			Main.list_W2N.get(myself).x1=Main.list_W2N.get(myself-1).x1-(car_height+10);
	   		        		}
	   		        		else if(Main.list_W2N.get(myself).x1>530){
	   		        			Main.list_W2N.get(myself).velocity=Main.list_W2N.get(myself-1).velocity;
	   	   		        		Main.list_W2N.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的

	   		        		}
	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
		        	 }
		        	 else {
		        		 
		        		 this.turn_left=true;
//########################转弯时控制角度的变化########################################	
		        		 if(this.x1<560) {
		        			 this.rotation_angle+=5;
		        			 this.x1+=this.velocity;
		        		 }else if(this.x1>=560) {
		        			 this.rotation_angle=90;
		        		 }
//########################转弯时控制角度的变化######################################## 
		        		 this.y1-=this.velocity;
		        		 if(this.y1<this.y2) {
		        			 //Main.list_W2N.remove(this);
		        			 Main.list_all.remove(this);
		        			 this.isAlive=false;
		        		 }
		        	 }//if语句
		       }//while语句	
			break;
			case "W2E"://西直走东;
				while(this.x1<=this.x2) {
	            	try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
	            	Main.map.repaint();
	            	isrun=true;
	            	this.x1+=this.velocity;
//##############################################判断红绿灯#################################################
		 			 /*****************第一阶段：在this.safety_line~this.safety_line+60之间开始减速*********************/ 
        			 while(isrun) {
	        		  if((MyCanvas.light_W_middle.get_status()==Light.light_red||MyCanvas.light_W_middle.get_status()==Light.light_yellow)&&(this.x1>=this.safety_line-130&&this.x1<this.safety_line)) {
	        		 		this.velocity=5;
	        		  }
	        		  /****************第二阶段：在this.safety_line~this.safety_line+10之间停止***********************/
    				  if((MyCanvas.light_W_middle.get_status()==Light.light_red)&&(this.x1<this.safety_line&&this.x1>=this.safety_line-100)) {
    					  	this.velocity=0;
    				  } 
    				 /****************第三阶段：在小于等于this.safety_line时恢复初始速度***********************/	
	        		  if((this.x1>=this.safety_line)) {
	        			  	this.velocity=original_V;
	        		  }
	        		  isrun=false;
	        		  } //while循环 
//##############################################判断红绿灯#################################################
//**************************************判断车间距****************************************************
	        		  for(int i=0;i<Main.list_W2E.size();i++) {
	   		        	 if((Main.list_W2E.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_W2E.get(i).hashCode())) {
	   		        		 myself=i;
	   		        		if((this.x1<=this.x2)&&(Main.list_W2E.get(myself-1).x1-(Main.list_W2E.get(myself).x1+Car.car_height)<=20)) {
	   		        			Main.list_W2E.get(myself).velocity=Main.list_W2E.get(myself-1).velocity;
	   		        			Main.list_W2E.get(myself).x1=Main.list_W2E.get(myself-1).x1-(car_height+10);
	   		        		}

	   		        	 }
	        		  } //for循环
//**************************************判断车间距****************************************************
	            if(this.x1>this.x2) {
	            	Main.list_W2E.remove(this);
	            	Main.list_all.remove(this);
	            	this.isAlive=false;
	            }//if判断结束
	            }//while循环结束
			break;
			case "W2S"://西右转南;
				while(this.y1<=this.y2) {
            		try {Thread.sleep(Car.time);}catch(InterruptedException e) {e.printStackTrace();}
            		Main.map.repaint();
            		if(this.x1<=425) {
            			this.x1+=this.velocity;
//**************************************判断右转****************************************************
    				    this.turn_right=false;
//**************************************判断右转****************************************************
//**************************************判断车间距****************************************************
    	        		  for(int i=0;i<Main.list_W2S.size();i++) {
    	   		        	 if((Main.list_W2S.size()>=2)&&(i!=0)&&(this.hashCode()==Main.list_W2S.get(i).hashCode())) {
    	   		        		 myself=i;
    	   		        		if((Main.list_W2S.get(myself-1).x1<=425)&&(Main.list_W2S.get(myself-1).x1-(Main.list_W2S.get(myself).x1+Car.car_height)<=20)) {
    	   		        			Main.list_W2S.get(myself).velocity=Main.list_W2S.get(myself-1).velocity;
    	   		        			Main.list_W2S.get(myself).x1=Main.list_W2S.get(myself-1).x1-(car_height+10);
    	   		        		}
    	   		        		else if(Main.list_W2S.get(myself).x1>425){
    	   		        			Main.list_W2S.get(myself).velocity=Main.list_W2S.get(myself-1).velocity;
    	   		        			Main.list_W2S.get(myself-1).velocity+=10;//这里之所前面的速度加10是因为防止转完后出现车辆的重叠，因为转弯完后是没有进行车距的判断的
    	   		        		}
    	   		        	 }
    	        		  } //for循环
//**************************************判断车间距****************************************************
            		}
            		else {
		        		 //右旋转90度，未写
            			 this.turn_right=true;
		        		 this.y1+=this.velocity;
		        		 if(this.y1>this.y2) {
		        			 Main.list_W2S.remove(this);
		        			 Main.list_all.remove(this);
		        		 this.isAlive=false;
		        		 }
		        	 }//if语句
			 }//while循环
			break;
			}//switch语句
			
		}//while循环
		
	}//run方法
}

代码写得有点冗余，将就看下吧！

后感

这个小项目呢也是我经历了许多艰难完成的，当时基础也比较烂，现在也一样，很多时候基础知识也不会用！还需要翻书确认一下才行！只能说java太博大精深了。最后也是希望在学java的小伙伴们学习的话就要坚持，多打代码，将那些常用的类都去翻看API然后实践一下那些方法！我现在就是后悔啊！当时没去实践那些，现在运用起来很困难的！目前我也是大二学生，读下学期。你别看这个项目怎么样，其实现在的我的编程能力超烂的！真的，只是这个我花费的时间多一点而已，然后去做，但是更多的是我平常都没去多实践，总想着想要拓宽自己的广度，所以我都是半灌水的！最后也是希望跟我一样的伙伴可以坚持下去吧！别的我也没什么好说的了！如果你觉得你也迷茫的话我们可以互相加微信哦！嘿嘿！互相学习和指导！

2020年11月11日22点21分
交流的话，请加我微信，放心我没其他想法，只是想互相交个技术上的朋友，我现在不经常弄技术上的东西，所以不怎么写博客和代码了，不过只是暂时性的，因为有其他事儿忙！不过交流我的项目的话，我还是很乐意滴！
lvlvcx137！！！

该项目素材

我为大家准备了两份素材，一个呢是我整个工作空间，一个只是src文件里面包含了图片文件夹和整个的源程序文件，你们要是想要的话可以自己选择获取

2022/04/20 更新，由于以前的百度链接提取后导入 IDE 中容易出现乱码，所以这里重新上传下：

整个工作空间百度网盘链接+提取码：vnuu
GitHub 地址 -推荐
希望看到这里的给我的GitHub个 star 呗？嘿嘿！祝好运^{(*￣(oo)￣)}

ITISummer

关注

10
点赞
踩
49

收藏

觉得还不错? 一键收藏
4
评论
java实现十字路口交通管理系统

前言首先我想先忏悔一下吧！我以前发的几文章都是从书上复制的啦！由于我刚开始写博客，并且自己的水平有限，对知识的理解也很有限，所以要写一篇自己的理解的文章很难，但是迫于知识的分享这个积极心态！我终究复制了我读的一些书上面的别人优良的成果！所以先来忏悔一下，免得如果有人从书上面看到了相同的内容也不要惊讶啊！然后这篇文章内容呢是我大二上学期刚学习java的时候我们课任老师给我们出的一道课程设计附加题。...
复制链接

扫一扫