java模拟十字路口交通 swing界面

原创 于 2023-06-03 20:06:08 发布 · 442 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #开发语言
博客提及了Hufan主类，结合标签推测与Java开发相关。

在这里插入图片描述

Hufan主类

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
 
public class Hufan extends JFrame implements ActionListener {
	static HuPanel hp;
	JMenuBar jmb;
	JMenu jm1, jm2;
	JMenuItem jmi1, jmi2, jmi3, jmi4;
	StartPanel sp;
 
	public static void main(String[] args) {
		new Hufan();
	}
 
	public Hufan() {
		jmb = new JMenuBar();
		jm1 = new JMenu("游戏");
		jmi1 = new JMenuItem("开始模拟");
		jmi1.addActionListener(this);
		jmi2 = new JMenuItem("暂停游戏");
		jmi2.addActionListener(this);
		jmi3 = new JMenuItem("退出游戏");
		jmi3.addActionListener(this);
		jm1.add(jmi1);
		jm1.add(jmi2);
		jm1.add(jmi3);
		jm2 = new JMenu("控制");
		jmi4 = new JMenuItem("设置");
		jmi4.addActionListener(this);
		jm2.add(jmi4);
		jmb.add(jm1);
		jmb.add(jm2);
		this.setJMenuBar(jmb);
 
		sp = new StartPanel();
		new Thread(sp).start();
		this.add(sp);
		this.setTitle("模拟交通灯");
		this.setSize(700, 700);
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setVisible(true);
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		if (e.getSource() == jmi1) {
			sp.isLive = false;
			this.remove(sp);
			hp = new HuPanel();
			this.add(hp);
			this.setVisible(true);
		} else if (e.getSource() == jmi2) {
			if (jmi2.getText().equals("暂停游戏")) {
				Car.zanTing = false;
				hp.zanTing = false;
				Light.kaiGuan = false;
				jmi2.setText("继续游戏");
			} else if (jmi2.getText().equals("继续游戏")) {
				Car.zanTing = true;
				hp.zanTing = true;
				Light.kaiGuan = true;
				jmi2.setText("暂停游戏");
			}
		} else if (e.getSource() == jmi3) {
			System.exit(0);
		} else if (e.getSource() == jmi4) {
			new Set(this, "设置", true);
		}
	}
}
 
class StartPanel extends JPanel implements Runnable {
	int info = 0;
	boolean isLive = true;
 
	public void paint(Graphics g) {
		super.paint(g);
		g.fillRect(0, 0, 700, 700);
		g.setColor(Color.red);
		g.setFont(new Font("微软雅黑", Font.BOLD, 30));
		if (info % 2 == 0) {
			g.drawString("Java模拟交通", 230, 300);
		}
	}
 
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			info++;
			this.repaint();
			if (isLive == false) {
				break;
			}
		}
	}
}
 
class HuPanel extends JPanel implements Runnable {
	static CopyOnWriteArrayList<MyCar> vtCar = new CopyOnWriteArrayList<MyCar>();
	static CopyOnWriteArrayList<Light> vtLight = new CopyOnWriteArrayList<Light>();
	ZhaoShi zs = null;
	Random r = new Random();
	boolean zanTing = true;
	static int carNum = 15;
	boolean creatMyCar = true;
 
	public HuPanel() {
		init();
		vtLight.add(new Light(306, 285, 0));
		vtLight.add(new Light(285, 365, 1));
		vtLight.add(new Light(365, 406, 2));
		vtLight.add(new Light(406, 305, 3));
		// 启动灯线程
		Thread t = new Thread(new Light());
		t.start();
		// 启动生成对象车线程
		new Thread(this).start();
	}
 
	// 生成肇事车
	public void init() {
		switch (r.nextInt(4)) {
		case 0:
			zs = new ZhaoShi(315, 0, 0);
			break;
		case 1:
			zs = new ZhaoShi(0, 365, 1);
			break;
		case 2:
			zs = new ZhaoShi(365, 700, 2);
			break;
		case 3:
			zs = new ZhaoShi(700, 315, 3);
			break;
		}
		new Thread(zs).start();
	}
 
	// JFrame自动调用paint，paint是JPanel父类的方法，
	// 所以先super调用父类的paint方法
	public void paint(Graphics g) {
		super.paint(g);
		// 画十字车道
		g.setColor(Color.darkGray);
		g.fillRect(0, 300, 700, 6);
		g.fillRect(0, 400, 700, 6);
		g.fillRect(300, 0, 6, 700);
		g.fillRect(400, 0, 6, 700);
		g.setColor(Color.gray);
		g.fillRect(0, 350, 700, 2);
		g.fillRect(350, 0, 2, 700);
		g.setColor(Color.blue);
		// 画灯
		for (int i = 0; i < vtLight.size(); i++) {
			Light light = vtLight.get(i);
			g.setColor(Color.black);
			if (light.direct % 2 == 0) {
				g.fillRect(light.x, light.y, 35, 15);
			} else {
				g.fillRect(light.x, light.y, 15, 35);
			}
			// 绿灯
			g.setColor(Color.green);
			if (light.greenLight == true) {
				if (light.direct % 2 == 0) {
					g.fillOval(light.x, light.y + 2, 10, 10);
				} else {
					g.fillOval(light.x + 2, light.y, 10, 10);
				}
			}
			// 红灯
			g.setColor(Color.red);
			if (light.redLight == true) {
				if (light.direct % 2 == 0) {
					g.fillOval(light.x + 20, light.y + 2, 10, 10);
				} else {
					g.fillOval(light.x + 2, light.y + 20, 10, 10);
				}
			}
		}
		// 画车
		Iterator<MyCar> iter = Hufan.hp.vtCar.iterator();
		while (iter.hasNext()) {
			MyCar mycar = iter.next();
			g.setColor(mycar.colorCar);
			if (mycar.direct % 2 == 0) {
				g.fill3DRect(mycar.x, mycar.y, 20, 35, true);
			} else {
				g.fill3DRect(mycar.x, mycar.y, 35, 20, true);
			}
		}
		// 画肇事车
		g.setColor(Color.red);
		if (zs.direct % 2 == 0) {
			g.fill3DRect(zs.x, zs.y, 20, 35, true);
		} else {
			g.fill3DRect(zs.x, zs.y, 35, 20, true);
		}
		// 画肇事文字
		if (zs.text != null) {
			g.setFont(new Font("微软雅黑", Font.BOLD, 50));
			g.drawString(zs.text.info, zs.text.x, zs.text.y);
		}
	}
 
	// 得到到十字路口要转的方向
	public int getDirect(int d) {
		int i = r.nextInt(4);
		while (true) {
			if (i == d) {
				i = r.nextInt(4);
			} else {
				break;
			}
		}
		return i;
	}
 
	@Override
	public void run() {
		MyCar myCar = null;
		int newDirect;
		// TODO Auto-generated method stub
		while (true) {
			if (zanTing) {
				if (vtCar.size() < carNum) {
					if (this.creatMyCar) {
						switch (r.nextInt(4)) {
						case 0:
							newDirect = getDirect(0);
							myCar = new MyCar(315, 0, 0, newDirect, Color.blue);
							vtCar.add(myCar);
							break;
						case 1:
							newDirect = getDirect(1);
							myCar = new MyCar(0, 365, 1, newDirect, Color.green);
							vtCar.add(myCar);
							break;
						case 2:
							newDirect = getDirect(2);
							myCar = new MyCar(365, 700, 2, newDirect, Color.cyan);
							vtCar.add(myCar);
							break;
						case 3:
							newDirect = getDirect(3);
							myCar = new MyCar(700, 315, 3, newDirect, Color.orange);
							vtCar.add(myCar);
							break;
						}
						new Thread(myCar).start();
					}
				}
			}
 
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
 
 
 
 
 
    
    
     
     
    
    
Car父类
 

public class Car{  
    int x;  
    int y;  
    static int speed=10;  
    int direct;  
    //是否停车    
    boolean stopCar=true;  
    //停止线程  
    boolean isStop=true;  
    //暂停线程  
    static boolean zanTing=true;  
    boolean isLive=true;  
    public Car(int x,int y,int direct){  
        this.x=x;  
        this.y=y;  
        this.direct=direct;  
    }  
}  

import java.awt.Color;
import java.util.Iterator;
 
public class MyCar extends Car implements Runnable {
	// 到十字路口，往哪个方向
	int newDirect;
	Color colorCar;
	public boolean exit = true;
 
	public MyCar(int x, int y, int direct, int newDirect, Color colorCar) {
		// TODO Auto-generated constructor stub
		super(x, y, direct);
		this.newDirect = newDirect;
		this.colorCar = colorCar;
	}
 
	// 换方向
	@Override
	public void run() {
		while (exit) {
			if (zanTing) {
				switch (direct) {
				case 0:
					switch (newDirect) {
					case 1:
						if (y > 358)
							direct = newDirect;
						break;
					case 3:
						if (y > 302)
							direct = newDirect;
						break;
					}
					
					if (stopCar) {
						y += speed;
					}
					panDuan(x, y + 35, direct);
					break;
				case 1:
					switch (newDirect) {
					case 0:
						if (x > 302)
							direct = newDirect;
						break;
					case 2:
						if (x > 358)
							direct = newDirect;
						break;
					}
					
					if (stopCar) {
						x += speed;
					}
					panDuan(x + 35, y, direct);
					break;
				case 2:
					switch (newDirect) {
					case 1:
						if (y < 385)
							direct = newDirect;
						break;
					case 3:
						if (y < 335)
							direct = newDirect;
						break;
					}
					
					if (stopCar) {
						y -= speed;
					}
					panDuan(x, y, direct);
					break;
				case 3:
					switch (newDirect) {
					case 0:
						if (x < 335)
							direct = newDirect;
						break;
					case 2:
						if (x < 385)
							direct = newDirect;
						break;
					}
					
					if (stopCar) {
						x -= speed;
					}
					panDuan(x, y, direct);
					break;
				}
			}
			// 碰到边界，删除
			if (x < -100 || x > 910 || y < -100 || y > 910) {
				Hufan.hp.vtCar.remove(this);
				this.exit = false;// 如果死亡，退出线程
				this.isStop=false;
			}
			Hufan.hp.repaint();
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
 
	public void panDuan(int x, int y, int direct) {
		// 车碰车
		Iterator<MyCar> iter = Hufan.hp.vtCar.iterator();
		while (iter.hasNext()) {
			MyCar mycar = iter.next();
			if (direct % 2 == 0) {
				// if(x>=car.x&&x<=car.x+20&&y>=car.y&&y<=car.y+35){
				if (x >= mycar.x && x <= mycar.x + 20 && y >= mycar.y && y <= mycar.y + 40) {
					if (mycar.stopCar == false) {
						stopCar = false;
					} else {
						stopCar = true;
					}
				}
			} else {
				if (x >= mycar.x && x <= mycar.x + 40 && y >= mycar.y && y <= mycar.y + 20) {
					if (mycar.stopCar == false) {
						stopCar = false;
					} else {
						stopCar = true;
					}
				}
			}
			if(this.isStop==false){
				Hufan.hp.vtCar.remove(mycar);
			}
		}
		// 是否碰到灯
		for (int i = 0; i < Hufan.hp.vtLight.size(); i++) {
			Light light = Hufan.hp.vtLight.get(i);
			if (direct % 2 == 0) {
				if (x >= light.x && x <= light.x + 50 && y >= light.y && y <= light.y + 15) {
					if (light.direct == direct) {
						if (light.redLight == true) {
							stopCar = false;
						} else {
							stopCar = true;
							Iterator<MyCar> iter1 = Hufan.hp.vtCar.iterator();
							while (iter1.hasNext()) {
								MyCar mycar = iter1.next();
								if (light.direct == mycar.direct) {
									mycar.stopCar = true;
								}
							}
						}
					}
				}
			} else {
				if (x >= light.x && x <= light.x + 15 && y >= light.y && y <= light.y + 50) {
					if (light.direct == direct) {
						if (light.redLight == true) {
							stopCar = false;
						} else {
							stopCar = true;
							Iterator<MyCar> iter2 = Hufan.hp.vtCar.iterator();
							while (iter2.hasNext()) {
								MyCar mycar = iter2.next();
								if (light.direct == mycar.direct) {
									mycar.stopCar = true;
								}
							}
						}
					}
				}
			}
		}
 
	}
}
 
 
 
 
 
 

//肇事  
public class ZhaoShi extends Car implements Runnable{  
  Text text;  
  public ZhaoShi(int x, int y, int direct) {  
      super(x, y, direct);  
      // TODO Auto-generated constructor stub  
  }  
  public void panDuan(int x,int y,int direct){  
      // 碰到边界，从arrAcr删除  
      if (x < 0 || x > 700 || y < 0 || y > 700) {  
          this.isStop = false;  
          Hufan.hp.init();  
      }  
      //是否碰到灯     
    for(int i=0;i<Hufan.hp.vtLight.size();i++){    
        Light light=Hufan.hp.vtLight.get(i);    
        if(direct%2==0){    
            if(x>=light.x&&x<=light.x+50&&y>=light.y&&y<=light.y+15){  
              if(light.redLight==true&&light.direct==direct){  
                    text=new Text(100, 200, "报告长官：有人闯红灯！");  
                    new Thread(text).start();  
              }  
            }    
        }else{    
            if(x>=light.x&&x<=light.x+15&&y>=light.y&&y<=light.y+50){  
              if(light.redLight==true&&light.direct==direct){  
                    text=new Text(100, 200, "报告长官：有人闯红灯！");  
                    new Thread(text).start();  
              }  
            }    
        }    
    }   
  }  
  @Override  
  public void run() {  
      // TODO Auto-generated method stub  
      while(true){  
          if(zanTing){  
              switch(direct){    
                case 0:    
                    if(stopCar){   
                      y+=speed;     
                    }  
                    panDuan(x, y+35, direct);    
                    break;    
                case 1:    
                    if(stopCar){  
                      x+=speed;   
                    }  
                    panDuan(x+35, y, direct);    
                    break;    
                case 2:    
                    if(stopCar){  
                      y-=speed;    
                    }  
                    panDuan(x, y, direct);    
                    break;    
                case 3:    
                    if(stopCar){  
                      x-=speed;    
                    }  
                    panDuan(x, y, direct);    
                    break;    
                }  
          }  
          //如果死亡，退出线程  
          if(isStop==false){  
              break;  
          }  
          try {  
              Thread.sleep(50);  
          } catch (InterruptedException e) {  
              // TODO Auto-generated catch block  
              e.printStackTrace();  
          }  
      }  
  }  
}  

//交通灯类  
public class Light implements Runnable{  
  int x;  
  int y;  
  boolean redLight;  
  boolean greenLight;  
  int direct;  
  //红绿灯来回切换  
  static boolean kaiGuan=true;  
  static boolean zanTing=true;  
  public Light(){}   
  public Light(int x,int y,int direct){  
      this.x=x;    
    this.y=y;    
    this.direct=direct;   
  }  
  @Override  
  public void run() {  
      // TODO Auto-generated method stub  
      while(true){  
          if(kaiGuan){  
              for(int i=0;i<HuPanel.vtLight.size();i++){  
                  Light light=HuPanel.vtLight.get(i);   
                  if(light.direct%2==0){    
                      light.greenLight=false;    
                      light.redLight=true;    
                  }else{    
                      light.greenLight=true;    
                      light.redLight=false;    
                  }  
              }  
              //切换灯  
              this.kaiGuan=false;  
          }else{  
              for (int i = 0; i < HuPanel.vtLight.size(); i++) {  
                  Light light = HuPanel.vtLight.get(i);  
                  if (light.direct % 2 == 0) {  
                      light.greenLight = true;  
                      light.redLight = false;  
                  } else {  
                      light.greenLight = false;  
                      light.redLight = true;  
                  }  
              }  
              //切换灯  
              this.kaiGuan=true;  
          }  
          try {  
              Thread.sleep(5000);  
          } catch (InterruptedException e) {  
              // TODO Auto-generated catch block  
              e.printStackTrace();  
          }  
      }  
  }  
}  

import javax.swing.*;  
import java.awt.*;  
import java.awt.event.*;  
public class Set extends JDialog implements ActionListener{  
    JComboBox jcb,jcb2;  
    JPanel jp,jp2,jp3;  
    JLabel jl,jl2;  
    JButton jb,jb2;  
    public Set(Frame owner, String title, boolean modal){  
        super(owner,title,modal);  
        String speed[]={"5","6","7","8","9","10","11","12","13","14","15"};  
        jcb=new JComboBox(speed);  
        String CarSpeed=Car.speed+"";  
        jcb.setSelectedItem(CarSpeed);  
        jp=new JPanel();  
        jl=new JLabel("速度为：");  
        jp.add(jl);  
        jp.add(jcb);  
          
        jp2=new JPanel();  
        jb=new JButton("确定");  
        jb.addActionListener(this);  
        jb2=new JButton("取消");  
        jb2.addActionListener(this);  
        jp2.add(jb);  
        jp2.add(jb2);  
          
        jp3=new JPanel();  
        jl2=new JLabel("车辆数:");  
        String carNum[]={"5","6","7","8","9","10","11","12","13",  
                "14","15","16","17","18","19","20"};  
        jcb2=new JComboBox(carNum);  
        String num=HuPanel.carNum+"";  
        jcb2.setSelectedItem(num);  
        jp3.add(jl2);  
        jp3.add(jcb2);  
        this.add(jp,"North");  
        this.add(jp3);  
        this.add(jp2,"South");  
        this.setSize(200, 200);  
        this.setVisible(true);  
    }  
    @Override  
    public void actionPerformed(ActionEvent e) {  
        // TODO Auto-generated method stub  
        if(e.getSource()==jb){  
              
            Car.speed=Integer.parseInt((String) jcb.getSelectedItem());  
            HuPanel.carNum=Integer.parseInt((String) jcb2.getSelectedItem());  
              
            this.dispose();  
        }else{  
            this.dispose();  
        }  
    }  
}  

//处理肇事类  
public class Text implements Runnable{  
  static int x;  
  static int y;  
  static String info="";  
  static boolean isLive=false;  
  static int times;  
  public Text(){}  
  public Text(int x,int y,String info){  
      this.x=x;  
      this.y=y;  
      this.info=info;  
  }  
  @Override  
  public void run() {  
      // TODO Auto-generated method stub  
      while(true){  
          if(isLive){  
              try {  
                  Thread.sleep(3000);  
              } catch (InterruptedException e) {  
                  // TODO Auto-generated catch block  
                  e.printStackTrace();  
              }  
              info="";  
              isLive=false;  
          }  
          if(isLive==false){  
              break;  
          }  
      }  
  }  
}
浅之竹
关注
traffic-flow-simulation:使用Java和Processing核心进行渲染的可视化仿真道路交叉口交通流
04-28
交通流模拟 道路交叉口交通流的可视化模拟。 结合使用Java和Processing进行渲染
十字路口交通模拟程序设计分析（JAVA）
08-27
对十字路口交通模拟程序的设计分析，有源代码（JAVA）
模拟实现十字路口交通灯管理系统（Java）
毕业作品网站
11-21 1860
4.2.1 J2EE应用程序的构建与部署 26。4.2.2 具体运行过程以及后期维护 26。第1章 开发语言和开发工具简介 2。1.1.1 Java语言的特点 2。1.2.2 Swing 的概述 5。4.1 软件测试的目的和原则 25。1.2.3 Swing的特点 6。1.3.2 JDBC的功能 7。1.4 系统的必要性和可行性 7。第2章 系统分析和总体规划 9。4.2 软件的运行与安装 26。1.1 Java技术简介 2。1.2.1 GUI的概述 5。1.3 JDBC技术简介 6。
7-5 无饿死互斥
C_cai_niao的博客
01-17 449
参考https://blog.csdn.net/booksyhay/article/details/82769005 在如图中所示的程序中，while语句是一个无限循环; 换句话说，一旦线程离开临界区，它就会循环到顶部并尝试再次获取互斥锁。 想象一下，线程A获取互斥锁，线程B和C等待。 当A离开时，B进入，但在B离开之前，A循环回来加入到队列中和C一起排队. B离开时，无法保证C接下来会执行。 ...
<<Head First设计模式>>之状态模式学习篇
ccf19881030的专栏
12-04 8168
最近在公司闲着没事干，看了一下>一书，感觉还蛮有意思，设计模式涉及到OO的设计思想和OO的设计原则。这本书是采用Java语言描述的。由于我比较熟悉C++，所以看完之后想使用C++来实现。由于想要结合状态模式和工厂模式做Windows计算器，所以重点看了一下状态模式，并且将<<Head First设计模式>>一书中以糖果机为例子讲述状态模式的例子使用C++做了一篇，加深我对状态模式的理解。大家如
JAVA中的swing
qq_53280238的博客
04-17 225
Graphical User Interface，主要用来实现桌面应用使用的技术，能够在桌面系统提供各种功能，比如：office，qq，浏览器等都算是桌面应用。event，事件有三大要素：事件源，事件对象，事件监听器。以坐标的方式确定位置。
交通信号灯
dengyilang33的博客
06-17 1576
课程设计
java实现十字路口交通管理系统
Summer's Blog
03-10 5119
前言 首先我想先忏悔一下吧！我以前发的几文章都是从书上复制的啦！由于我刚开始写博客，并且自己的水平有限，对知识的理解也很有限，所以要写一篇自己的理解的文章很难，但是迫于知识的分享这个积极心态！我终究复制了我读的一些书上面的别人优良的成果！所以先来忏悔一下，免得如果有人从书上面看到了相同的内容也不要惊讶啊！然后这篇文章内容呢是我大二上学期刚学习java的时候我们课任老师给我们出的一道课程设计附加题。...
交通信号灯模拟（Java实现）
qq_51063273的博客
07-19 4303
交通信号灯模拟 模拟实现十字路口的交通灯管理系统逻辑
java十字路口模拟_模拟实现十字路口交通灯管理系统（Java+GUI）毕业论文+开题报告+设计源码...
weixin_39671935的博客
02-19 885
摘要模拟实现十字路口交通灯管理系统是一个应用于交通管理的软件，实现了对任何一个交通路口进行模拟 的 功能，以方便交通管理部门能够更好的管理交通，使这个路口达到最优化。本设计完成了系统中的车辆模拟，时间计时，历史查询等功能。该系统使用Java语言，采用Mysql(10g)、PL-Sql、GUI Swing 、JDBC等技术，基于 Eclipse + Sun OS 5.8开发平台开发设计的，整个系...
基于Java的交通模拟系统仿真系统 文档+源码
毕业作品网站
02-23 1417
二． 交通仿真系统设计 4。应仿真的交通活动： 3。2.1 类的设计 4。
JAVA交通信号灯大作业（源码+报告+视频演示）
垂死病中惊坐起，菜鸟竟是我自己，于是含泪写下博客
04-15 1910
此资料包含上交的JAVA课程大作业源码+报告+视频演示，具体大作业为交通信号灯。
用java构造类模拟交通灯,java swing界面模拟交通灯
weixin_42588877的博客
03-27 455
本例车到了路口不能转向。import java.awt.*;import java.util.*;import javax.swing.*;/*** 2012.4.4* @author Administrator* zwyjg@163.com*/public class Hufan extends JFrame{public static HuPanel hp;public static H...
java 交通绘图_Java模拟交通路况
weixin_35503004的博客
02-24 359
【实例简介】JAVA模拟交通路况，不过，没有写报告文档。但是呢，程序已经有了，可以直接运行的。实验报告电子文档自己写出来，应该没有问题吧，我把所要积分降到可以得到的最少了，我也要积分呀，亲【实例截图】【核心代码】Java模拟交通路况├── bin│ └── com│ └── briup│ ├── Exception│ │ └── Traf...
JAVA7K面试题——交通灯管理系统
我的便当盒
04-07 895
第六讲. 代码编写——MainClass：实例化相应的类，通过调用相应方法(这里就是构造方法)启动这些线程，来运行系统。第五讲 .代码编写——LampController交通灯控制器。第四讲.代码编写——Lamp枚举。第三讲.代码编写——Road类。
基于JavaSwing开发模拟十字路口的红绿灯变化及车辆移动+作业要求 课程设计
QQ2892034822的博客
09-18 889
基于JavaSwing开发模拟十字路口的红绿灯变化及车辆移动+作业要求： （大作业）基于JavaSwing开发模拟十字路口的红绿灯变化及车辆移动+作业要求： （大作业）这条没有，需要加这个功能（更改车道数） 【车道数有个默认值，也可以设定，】这条没有，需要加这个功能（更改车道数） 【车道数有个默认值，也可以设定，】假设垂直和水平方向都是单行，所有车辆的移动速度相同。要求：模拟十字路口的红绿灯变化及车辆移动，要求：模拟十字路口的红绿灯变化及车辆移动，开发环境: Windows操作系统。
Java电子交通模拟系统
QQ79856539的博客
02-23 257
该系统使用Java语言，采用Oracle(10g)、PL-Sql、GUI Swing 、JDBC等技术，基于 Eclipse + Sun OS 5.8开发平台开发设计的，整个系统基于MVC模式(M-模型层，V-视图层，C-控制器)完成了程序界面的设计及查询功能模块的具体实现.使用Oracle(10g)完成了数据库具体设计，进行从而完成了整个系统的开发。电子交通模拟系统是一个应用于交通管理的软件，实现了对任何一个交通路口进行模拟 的 功能，以方便交通管理部门能够更好的管理交通，使这个路口达到最优化。
黑马程序员-JAVA-交通灯模拟
sisel的专栏
04-14 1107
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-在传智播客的视频中有这样的一个题目：交通灯模拟。今天我也尝试做一个：交通灯模拟的需求分析 交通灯是一个路口交通控制系统，交通灯模拟即又要模拟路口的交通，也要模拟交通灯控制 路口的交通需求包括车流通过和行人通过，行人走人行道（与车流交错）或是天桥/地下，车流走交通灯路口或是立交桥。 交通灯控制有控制需求的交错点，比如
基于Java语言实现全国交通咨询模拟
毕业作品网站
05-24 1720
设置顶点 vi 到顶点 vk 的最短路径已知为 Lik，顶点 vk 到 vj 的最短路径已知为 lkj,顶点 vi 到 vj 的路径为 li，则 vi 到 vj 的最 短路径为: min(Lk+Lkj),Lij), vk 的取值为图中所有顶点，则可获得 vi 到 vj 的最短路径。Fxml 的路径设置和 Java 默认的路径设置不尽相同，Java 中的相对路径默认实现是从工程文件的根目录开始寻址，而 JavaFx 是从当前文件夹通过相对路径寻址。提供对列车时刻表的管理功能(增加，删除，查询，修改)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值