java开发坦克大战
坦克大战游戏演示
为什么选择这个项目
1、好玩
2、涉及到java各个方面的技术
1、java面向对象编程；
2、界面编程；
3、绘图技术；
4、多线程；
5、文件i/o操作；
6、数据库
3、巩固旧知识，学习新知识
java绘图坐标体系
绘图坐标本系--介绍
坐标原点位于左上角，以像素为单位。像素是计算机屏幕上最小的显示单位。在java 的坐标系中，第一个是X坐标，表示当前位置为水平方向，距离坐标原点X个像素；第二个是Y坐标，表示当前位置为垂直方向，距离坐标原点Y个像素。
坐标体系--像素
计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行，整个计算机屏幕共有480000个像素。现在的计算机可以支持更高的分辨率，也就是说，屏幕上可以显示更多的像素。因此，像素是一个密度单位，而厘米是长度单位，两者无法比较。
绘图原理(1)[Window013.java]
Component类提供了两个和绘图相关最重要的方法：
1、paint(Graphics g)绘制组件的外观
2、repaint()刷新组件的外观
当组件第一次在屏幕显示的时候，程序会自动的调用paint()方法来绘制组件
import java.awt.*;
import javax.swing.*;
public class Window013 extends JFrame{
//定义组件
MyPanel mp=null;
public static void main(String[] args) {
Window013 th=new Window013();
}
public Thread01(){
//创建组件
mp=new MyPanel();
//加入组件
this.add(mp);
//设置窗体
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//定义一个MyPanel(我自己的面板是用于绘图和显示绘图的区域)
class MyPanel extends JPanel{
//重写(覆盖)JPanel的paint方法
public void paint(Graphics g){//Graphics是绘图的重要类，可以把它理解成一只画笔
//1、调用父类函数，完成初始化任务
super.paint(g);//super.paint(g);这句话不能少
System.out.println("Paint被调用");//用于测试绘图原理2paint调用
//先画一个圆
g.drawOval(10, 10, 30, 30);//drawOval方法是画圆
}
}
------------------------------------------------------------------------------ 绘图原理(2)
在以下情况paint()将会被调用：
1、窗口最小化，再最大化
2、窗口的大小发生变化
3、repaint函数被调用
java绘图技术--Graphics
Graphics类[Window014.java]
Graphics类你可以理解就是画笔，为我们提供了各种绘制图形的方法：[多看jdk帮助文档]
1、画直线 drawLine(int x1,int y1,int x2,int y2);
2、画矩形边框 drawRect(int x,int y,int width,int height);
3、画椭圆边框 drawOval(int x,int y,int width,int height);
4、填充矩形 fillRect(int x,int y,int width,int height);
5、填充椭圆 fillOval(int x,int y,int width,int height);
6、画图片 drawImage(Image img.int x,int y,..);
7、画字符串 drawString(String str,int x,int y);
8、设置画笔的字体 setFont(Font font);
9、设置画笔的颜色 setColor(Color c);
//java画图Graphics绘图类的使用方法
import java.awt.*;
import javax.swing.*;
public class Window014 extends JFrame{
//定义组件
MyPanel1 mp=null;
public static void main(String[] args) {
Window014 th=new Window014();
}
public Window014(){
//构建组件
mp=new MyPanel1();
//加入组件
this.add(mp);
//设置窗体
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//定义一个MyPanel(我自己的面板是用于绘图和显示绘图的区域)
class MyPanel1 extends JPanel{
//重写(覆盖)JPanel的paint方法
public void paint(Graphics g){//Graphics是绘图的重要类，可以把它理解成一只画笔
//1、调用父类函数，完成初始化任务
super.paint(g);
//画一个直线
g.drawLine(10, 10, 40, 10);
//画矩形边框
g.drawRect(50, 50, 40, 40);
//画椭圆边框
g.drawOval(100, 100, 60, 60);
//画填充矩形
g.setColor(Color.blue);
g.fillRect(10, 150, 70, 70);
//画填充椭圆
g.setColor(Color.red);//设置画笔颜色
g.fillOval(200, 50, 80, 80);
}
}
------------------------------------------------------------------------------
//画图Graphics画图类--画图片--画字[Window015.java]
import java.awt.*;
import javax.swing.*;
public class Window015 extends JFrame{
//定义组件
MyPanel1 mp=null;
public static void main(String[] args) {
Window015 th=new Window015();
}
public Window015(){
//构建组件
mp=new MyPanel1();
//加入组件
this.add(mp);
//设置窗体
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//定义一个MyPanel(我自己的面板是用于绘图和显示绘图的区域)
class MyPanel1 extends JPanel{
//重写(覆盖)JPanel的paint方法
public void paint(Graphics g){//Graphics是绘图的重要类，可以把它理解成一只画笔
//1、调用父类函数，完成初始化任务
super.paint(g);
//在面板上画出图片
Image
im=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/F22.jpg"));
//实现
g.drawImage(im, 0, 0, 300, 200, this);
//如何画出字
g.setColor(Color.red);
g.setFont(new Font("黑体",Font.BOLD,40));
g.drawString("祖国万岁", 100, 100);
//画弧形
g.drawArc(100, 100, 120, 200, -50, -100);
}
}
java事件处理机制
如何通过键盘或鼠标的控制使Java程序中的功能有响应?
java事件处理机制--初步介绍
java事件处理是采取“委派事件模型”。所谓“委派事件模型”是指当事件发生时，产生事件的对象(即事件源)，会把此“信息”传递给“事件的监听者”处理的一种方式，而这里所说的“信息”实际上就是java.awt.event事件类库里某个类所创建的对象，我们暂时把它称为“事件的对象”。
比如：当按下按钮时，就会在按钮触发一个“事件”，程序就会产生一个“事件对象”来表示这个事件，并把这个“事件对象”传递给“事件的监听者”，“事件的监听者”再根据“事件对象”的类型进行相应处理。
为了让“产生事件的对象”[比如按钮]知道要把事件传递给哪一个“事件监听者”，我们必需先把“事件监听者”在“产生事件的对象”注册，这个操作也就是要告知“产生事件的对象”要把事件传递给它。
实例[Window016.java]
/**
* 功能:事件处理机制
*/
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Window016 extends JFrame implements ActionListener{
//定义组件
JPanel mp=null;
JButton jb1,jb2;
public static void main(String[] args) {
Window016 win=new Window016();
}
//构造函数
public Window016(){
//创建组件
mp=new JPanel();
jb1=new JButton("黑色");
jb2=new JButton("红色");
//设定布局管理器
//加入组件
mp.setBackground(Color.black);
this.add(mp);
this.add(jb1,BorderLayout.NORTH);
this.add(jb2,BorderLayout.SOUTH);
//猫类在监听
Cat mycat1=new Cat();
jb1.addActionListener(mycat1);
jb2.addActionListener(mycat1);
//注册监听
jb1.addActionListener(this);
jb2.addActionListener(this);
//指定action命令
jb1.setActionCommand("黑色");
jb2.setActionCommand("红色");
//JFrame窗体设置
this.setTitle("事件处理机制");
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }
//对事件处理的方法
public void actionPerformed(ActionEvent e) {
//判断是哪个按钮被点击
if(e.getActionCommand().equals("黑色")){
System.out.println("点击了黑色按钮");
mp.setBackground(Color.BLACK);
}else if(e.getActionCommand().equals("红色")){
System.out.println("点击了红色按钮");
mp.setBackground(Color.RED);
}else{
System.out.println("不知道");
}
}
}
class Cat implements ActionListener{
public void actionPerformed(ActionEvent arg0) {
if(arg0.getActionCommand().equals("黑色")){
System.out.println("Cat也知道你按下了黑色按钮");
}else if(arg0.getActionCommand().equals("红色")){
System.out.println("Cat也知道你按下了红色按钮");
}else {
System.out.println("Cat也不知道");
}
}
}
------------------------------------------------------------------------------ 实例[Window017.java]
/**
* 功能：加深对事件处理机制的理解
* 1、通过上下左右键，来控制一个小球的移动。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Window017 extends JFrame {
//设定组件
MyPanels mp=null;
public static void main(String[] args) {
Window017 win=new Window017();
}
//构造函数
public Window017(){
//构建组件
mp=new MyPanels();
//监听
this.addKeyListener(mp);
//加入组件
this.add(mp);
//设置窗体
this.setTitle("键盘事件监听");
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
//定义自己的面板
class MyPanels extends JPanel implements KeyListener{ int x=10,y=10;
public void paint(Graphics g){
super.paint(g);
g.fillOval(x, y, 10, 10);
}
public void keyPressed(KeyEvent e) {//keyPressed代表键被按下System.out.println("被按下"+((char)e.getKeyCode()));
if(e.getKeyCode()==KeyEvent.VK_DOWN){
System.out.println("向下");
y++;
}else if(e.getKeyCode()==KeyEvent.VK_UP){
System.out.println("向上");
y--;
}else if(e.getKeyCode()==KeyEvent.VK_LEFT){
System.out.println("向左");
x--;
}else if(e.getKeyCode()==KeyEvent.VK_RIGHT){
System.out.println("向右");
x++;
}
//调用repaint()函数，来重绘界面
this.repaint();
}
public void keyReleased(KeyEvent e) {//keyReleased代表键被弹起}
public void keyTyped(KeyEvent e) {//keyTyped代表具体的值被输出
}
}
java事件处理机制--深入理解
前面提到了几个重要的概念
1、事件源；
2、事件；
3、事件监听器
这几个概念非常重要，必需要搞清楚。
1、事件源
事件源是一个产生(或触发)事件的对象，比如前面的JButton的一个对象jb1。当这个事件源对象的某些状态以某种方式发生变化时，就会产生某种类型的事件(一个事件源可能会生成多个不同类型的事件)。如果某个组件(对象)希望得到事件源产生的事件，就需要在这个事件源上注册。
2、事件
事件就是承载事件源状态改变时的信息对象。或者说，事件是事件源事件监听器传输事件源状态信息的载体。在用户与GUI组件进行交互时就会生成事件，比如当鼠标在面板中移动时，就会生成一个鼠标移动事件的对象，而这个对象保存着当前鼠标在面板中位置信息。
WindowEvent 当一个窗口激活、关闭、失效、恢复、最小化...
3、事件监听器接口
事件源产生一个事件，可以传送给事件监听者处理，那么怎样才能编写一个事件监听者呢？
事件监听者实际上就是一个类，该类实现了某个事件监听器接口、比如前面我们案例中的MyPanel就是一个类，它实现了ActionListener接口，它就可以作为一个事件监听者，对接受到的事件进行处理。
事件监听器接口有多种，不同的事件监听器接口可以监听不同的事件，一个类可以实现一个事件监听接口，也可以实现多个监听接口，这些接口在java.awt.event和javax.swing.event包中定义。
java事件处理机制--总结
总结--事件编程步骤：
1、编写事件处理类(事件监听者)
2、根据需求给事件处理类实现监听器接口
3、在事件处理中重写(实现)其事件处理的函数
4、在事件源类中指定该事件的监听器(响应者)是谁
注意事项：
1、java采用委托机制处理事件
2、java中的事件是分类的，比如对窗体事件、鼠标事件、按键事件、操作事件[按按钮]
3、java中一个类要监听某个事件，则必需实现相应的事件监听接口
4、事件监听接口有多种，程序员应当针对不同的情况，实现不同的监听接口，比如监听鼠标事件就应当实现MouseListener;要监听键盘事件，就应当实现KeyListener..
5、在实现监听接口的类(事件监听类/者)中，需要重写处理函数，比如实现了ActionListener接口，就应当重写actionPerformed(ActionEvent e),可以参考前面的事件监听器接口表格
6、在事件源中需要注册事件监听类。否则事件监听类接收不到事件源发生的事件。
一个类要实现监听的步骤：
a、实现相应的接口[KeyListener/MouseListener/ActionListener/WindowListener]
b、把接口的处理方法根据需要重新编写(Override)
c、在事件源上注册监听
d、事件传递是靠事件(类)对象
实例[Window018.java]
/**
* 单事件源、多事件监听，多事件处理
*/
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Window018 extends JFrame{
//设定组件
MyPanel mp=null;
public static void main(String[] args) {
Window018 win=new Window018();
}
public Window018(){
//创建组件
mp=new MyPanel();
//注册监听
this.addMouseListener(mp);
this.addMouseMotionListener(mp);
this.addKeyListener(mp);
this.addWindowListener(mp);
//加入组件
this.add(mp);
//设置窗体
this.setTitle("事件多监听多处理");
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
//1、让MyPanel知道鼠标按下的消息，并且知道点击的位置(x,y)
//2、让MyPanel知道哪个键按下了
class MyPanel extends JPanel implements MouseListener, MouseMotionListener,KeyListener,WindowListener{
public void paint(Graphics g){
super.paint(g);
}
//鼠标点击(mouseClicked)
public void mouseClicked(MouseEvent e) {
System.out.println("鼠标点击了x="+e.getX()+"y="+e.getY());
}
//鼠标移动到MyPanel(mouseEntered)
public void mouseEntered(MouseEvent e) {
System.out.println("鼠标移动到MyPanel上了");
}
//鼠标离开MyPanel(mouseExited)
public void mouseExited(MouseEvent e) {
System.out.println("鼠标离开MyPanel上了");
}
//鼠标按下去(mousePressed)
public void mousePressed(MouseEvent e) {
System.out.println("鼠标被按下了");
}
//鼠标松开(mouseReleased)
public void mouseReleased(MouseEvent e) {
System.out.println("鼠标被松开了");
}
//鼠标拖拽(mouseDragged)
public void mouseDragged(MouseEvent e) {
System.out.println("鼠标拖拽x="+e.getX()+"y="+e.getY()); }
//鼠标移动(mouseMoved)
public void mouseMoved(MouseEvent e) {
System.out.println("鼠标移动时X="+e.getX()+"Y="+e.getY()); }
//键输入值(keyTyped)，F(1-12)无响应
public void keyTyped(KeyEvent e) {
System.out.println("按下了"+e.getKeyChar()+"键");
}
//键按下(keyPressed)
public void keyPressed(KeyEvent e) {
System.out.println("按下了"+e.getKeyChar()+"键");
}
//键松开(keyReleased)
public void keyReleased(KeyEvent e) {
System.out.println("按下了"+e.getKeyChar()+"键");
}
//打开窗口(windowOpened)
public void windowOpened(WindowEvent e) {
System.out.println("打开窗口(windowOpened)");
}
//窗口关闭(windowClosing)
public void windowClosing(WindowEvent e) {
System.out.println("窗口关闭(windowClosing)");
}
//窗口关闭(windowClosed)
public void windowClosed(WindowEvent e) {
System.out.println("窗口关闭(windowClosed)");
}
//窗口最小化(windowIconified)
public void windowIconified(WindowEvent e) {
System.out.println("窗口最小化(windowIconified)");
}
//恢复窗口(windowDeiconified)
public void windowDeiconified(WindowEvent e) {
System.out.println("恢复窗口(windowDeiconified)");
}
//激活窗口，使用窗口(windowActivated)
public void windowActivated(WindowEvent e) {
System.out.println("激活窗口(windowActivated)");
}
//窗口停用,切换窗口(windowDeactivated)
public void windowDeactivated(WindowEvent e) {
System.out.println("窗口停用(windowDeactivated)");
}
}
------------------------------------------------------------------------------ 线程--什么是进程
进程--概念
要解释线程，就必须明白什么是进程，就好象要搞清中国历史，就必须要了解春秋战国。什么是进程呢？
进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
要点：用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。
线程--概念
在明白进程后，就比较容易理解线程的概念。
什么是线程呢？
是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
线程
1、线程是轻量级的进程
2、线程没有独立的地址空间(内存空间)
3、线程是由进程创建的(寄生在进程)
4、一个进程可以拥有多个线程-->这就是我们常说的多线程编程
5、线程有几种状态：
a、新建状态(new)
b、就绪状态(Runnable)
c、运行状态(Running)
d、阻塞状态(Blocked)
e、死亡状态(Dead)
线程有什么用处
java程序中流传一句话，不会使用线程就别跟别人说自己学过java。目前绝大部分应用程序都会涉及到多并发的问题。只要应用程序涉及到并发，就离不开多线程编程。
线程--如何使用
在java中一个类要当作线程来使用有两种方法。
1、继承Thread类，并重写run函数
2、实现Runnable接口，并重写run函数
因为java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread 类方法来创建线程显然不可能java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。
通过继承Thread类来实现建立线程实例[Thread01.java]
/**
* 演示如何通过继承Thread来开发线程
*/
public class Thread01 {
public static void main(String[] args) {
//创建一个 Cat对象
Cat cat=new Cat();
//启动线程
cat.start();//.start()会导致run函数运行
}
}
class Cat extends Thread{
int times=0;
//重写run函数
public void run(){
while(true){
//休眠一秒
//1000表示1000毫秒
try {
Thread.sleep(1000);//sleep就会让该线程进入到Blocked阻塞状态,并释放资源。
} catch (Exception e) {
e.printStackTrace();
}
times++;
System.out.println("hello,world!"+times);
if(times==10){
//退出线程
break;
}
}
}
}
------------------------------------------------------------------------------- 通过Runnable接口来实现建立线程实例[Thread02.java]
/**
* 演示如何通过Runnable接口来开发线程
*/
public class Thread02{
public static void main(String []args){
Dog dog=new Dog();
//创建线程
Thread t=new Thread(dog);
//启动线程
t.start();
}
}
class Dog implements Runnable{//创建Runnable接口
public void run(){//重写run函数
int times=0;
while(true){
try{
Thread.sleep(1000);
}catch (Exception e) {
e.printStackTrace();
}
times++;
System.out.println("hello,wrold!"+times);
if(times==10){
}
}
}
}
------------------------------------------------------------------------------- 多线程实例演示[Thread03.java]
/**
*多线程Thread使用
*1、一个线程通过接收n来执行1+..+n得到和
*2、另一线程每隔1秒输出一次hello world!
*/
public class Thread03 {
public static void main(String[] args) {
Pig pig=new Pig(10);
Bird bird=new Bird(10);
//建立线程
Thread t1=new Thread(pig);
Thread t2=new Thread(bird);
//启动线程
t1.start();
t2.start();
}
}
//打印hello world!
class Pig implements Runnable{
int n=0;
int times=0;
public Pig(int n){
this.n=n;
}
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
times++;
System.out.println("我是一个线程，正在输出第"+times+"个hello world!");
if(times==n){
}
}
}
}
//算数学题
class Bird implements Runnable{//多线程时应使用implements接口来实现，不要使用extends继承
int n=0;
int res=0;
int times=0;
public Bird(int n){
this.n=n;
}
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
res+=(++times);
System.out.println("当前结果是："+res);
if(times==n){
System.out.println("最后的结果是："+res);
break;
}
}
}
}
------------------------------------------------------------------------------- 线程--区别
线程--继承Thread VS 实现Runnable的区别
从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，如果一定要说它们有什么区别，总结几点：
1、尽可能使用实现Runnable接口的方式来创建线程
2、在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程，如：Thread test=new Thread();
test.start();
3、在使用Runnable的时候需要先new一个实现Runnable的实例，之后用Thread调用，如:
Test implements Runnable
Test t=new Test();
Thread test=new Thread(t);
tset.start();
线程--深入理解
线程对象只能启动一个线程，见[Thread04.java]
/**
* 功能:使用线程的注意事项
* 不论继承Thread或实现Rnunable接口都不能使用start启同一个线程2次
*/
public class Thread04 {
public static void main(String[] args) {
Cat cat1=new Cat();
cat1.start();
//cat1.start();同一个线程，不能启动2次
Dog dog1=new Dog();
Thread t=new Thread(dog1);
t.start();
//t.start();同一个线程，不能启动2次
}
}
//猫类
class Cat extends Thread{
public void run(){
System.out.println("11");
}
}
//狗类
class Dog implements Runnable{
public void run(){
System.out.println("2");
}
}
------------------------------------------------------------------------------- 结论：不管是通过继承Thread，还是通过实现Runnable接口创建线程，它们的一个对象只能启动(即：start())一次。否则就会有异常抛出。
两种创建线程的方法的区别
创建线程有两种方法：1、继承Thread；2、实现Runnable接口；这两种方法有什么区别？用实现Runnable接口的特点
1、用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限；
2、用实现Runnable接口的方法，可以实现多个线程共享同一段代码(数据)；
因此建议大家如果你的程序有同步逻辑需求，则使用Runnable的方法来创建线程。
java线程的同步--提出问题
多线程的并发，给我们编程带来很多好处，完成更多更有效率的程序。但是也给我们带来线程安全问题。
java线程的同步--解决问题
解决问题的关键就是要保证容易出问题的代码的原子性，所谓原子性就是指：当a线程在执行某段代码的时候，别的线程必须等到a线程执行完后，它才能执行这段代码。也就是排队一个一个解决。
java处理线程两步的方法非常简单，只需要在需要同步的代码段，用:
synchronized(Object){你要同步的代码}
即可。
售票案例演示[Thread05.java]
/**
* 功能:使用线程的注意事项
* 线程并发同步锁synchronized(Object){}的使用
*/
public class Thread05 {
public static void main(String[] args) {
//定义一个售票窗口
TicketWindow tw1=new TicketWindow();
//使用三个线程同时启动
Thread t1=new Thread(tw1);
Thread t2=new Thread(tw1);
Thread t3=new Thread(tw1);
t1.start();
t2.start();
t3.start();
}
}
//售票窗口类
class TicketWindow implements Runnable {
//共有2000张票
private int nums=2000;
private Dog myDog=new Dog();
public void run() {
while(true){
//出票速度是1秒出一张
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
//认为if else要保证其原子性
//先判断是否还有票
synchronized(myDog){//synchronized(this){}为同步代码块
if(nums>0){
//显示售票信息
//Thread.currentThread().getName()得到当前线程的名字
System.out.println(Thread.currentThread().getName()+"正在售出第"+nums+"张票");
nums--;
}else{
//售票结束
break;
}
}
}
}
}
class Dog{
}
------------------------------------------------------------------------------- java线程的同步--解决问题
对同步机制的解释：
java任意类型的对象都有一个标志位，该标志位具有0、1两种状态，其开始状态为1，当某个线程执行了synchronized(Object)语句后，object对象的标志位变为0的状态，直到执行完整个synchronized语句中的代码块后，该对象的标志位又回到1状态。
当一个线程执行到synchronized(Object)语句的时候，先检查Object对象的标志位，如果为0状态，表明已经有另外的线程正在执行synchronized包括的代码，那么这个线程将暂时阻塞，让出CPU资源，直到另外的线程执行完相关的同步代码，并将Object对象的标志位变为状态，这个线程的阻塞就被取消，线程能继续运行，该线程又将Object的标志位变为0状态，防止其它的线程再进入相关的同步代码块中。
如果有多个线程因等待同一个对象的标志位面而处于阻塞状态时，当该对象的标志位恢复到1状态时，只会有一个线程能够进入同步代码执行，其它的线程仍处于阻塞的状态。特别说明：
1、上面所说的标志位用术语讲就是对象锁,文件锁。数据库会有行锁、表锁等
2、synchronized(object)//object(就是对象锁)可以是任意类型对象
韩顺平java坦克大战1.0版本_源代码
/**画坦克1.0 */ import java.awt.Color; import java.awt.Graphics; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.event.MouseMotionListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import javax.swing.JFrame; import javax.swing.JPanel; public class MyTankGame extends JFrame { MyPanel mp=null; public static void main(String[] args) { MyTankGame mtk=new MyTankGame(); } public MyTankGame() { mp=new MyPanel(); this.add(mp);//把面板加入窗体 //注册监听 this.addMouseListener(mp); this.addKeyListener(mp); this.addMouseMotionListener(mp); this.addWindowListener(mp); this.setTitle("坦克大战");//窗体标题 this.setSize(600,400);//大小，宽，高（像素） this.setLocation(300,300);//显示位置。左边距，上边距 //禁止用户改变窗口大小 this.setResizable(false); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true);//显示 } } //我的面板 class MyPanel extends JPanel implements
Java语言坦克大战游戏设计(附有代码和图片)
JISHOU UNIVERSITY 本科生毕业设计 题目：基于java语言坦克大战游戏开发作者： 学号： 所属学院：信息科学与工程学院 专业年级： 指导教师：职称： 完成时间： 吉首大学教务处制
目录 基于java语言坦克大战游戏开发 (1) 摘要 (1) Based on the development of Java language Tank Wars Game (2) 第一章游戏简要说明 (3) 第二章开发环境介绍 (4) 2.1 开发环境 (4) 2.2 java语言特点简介 (4) 2.3 Eclipse开发工具的简介 (5) 第三章系统总体设计 (6) 3.1程序功能的总和 (6) 3.2主体模块 (6) 3.3子弹模块 (6) 3.4坦克模块 (7) 3.5 墙模块 (7) 3.6血液模块 (7) 3.7爆炸模块 (8) 第四章游戏详细设计过程 (9) 4.1创建游戏窗口 (9) 4.2改变游戏背景颜色。 (11) 4.3创建坦克 (11) 4.4 让坦克动起来 (12) 4.5改变窗口的大小 (13) 4.6让坦克受控制 (14) 4.7创建一个Tank类 (15) 4.8让坦克向8个方向移动 (16)
4.9修改4.8中所设计的不足 (18) 4.10添加子弹类 (19) 4.11根据己方坦克的位置，打出子弹 (21) 4.12修改坦克停下来不能打出子弹的问题 (21) 4.13让坦克能够打出多发子弹 (23) 4.14解决炮弹不消亡和坦克出界的问题 (23) 4.15增加敌方坦克 (24) 4.16击毙出现的敌方坦克 (25) 4.17加入爆炸效果 (26) 4.18添加多辆敌方坦克 (27) 4.19让敌方坦克智能化 (29) 4.20建立游戏障碍物 (31) 4.21阻止坦克互相穿越 (32) 4.22为我方坦克添加大招和血条 (33) 4.23添加血块 (34) 4.24重新载入敌军或我军坦克 (35) 4.25加入图片 (35) 第五章游戏的可行性测试 (37) 5.1游戏界面介绍 (37) 5.2游戏运行测试 (40) 第六章总结 (43) 参考文献 (44)
项目坦克大战设计报告
《JA V A程序开发课程设计》项目设计 项目名称：TankWar 软件 专业：软件工程班级：13软工1班姓名：毛晨光学号：24 一、需求分析： 基本功能： 1.玩家控制的坦克能够四处移动并且打击敌方坦克； 2.敌方坦克能够随机四处移动并且打击玩家控制的坦克； 3.玩家控制的坦克拥有血量，而敌方坦克没有； 4.坦克受到攻击时血条会缩短； 5.敌方坦克被消灭完之后，提示游戏胜利； 6.用户方坦克被消灭后提示游戏结束； 特色功能： 1.坦克具有图片，不单单只是个圈圈。 2.增加了血包功能，地图上会随机出现一个血包，我方坦克开过会增加 血量。 二、系统设计： 类：实现游戏界面地图的初始化。 类：绘制和重绘功能。 :监听用户的键盘输入。 类：实现坦克的初始化，绘制，移动，发射等功能。 ：实现敌方坦克的初始化，绘制，移动，发射等功能。 类：实现炮弹的初始化，绘制，移动，攻击功能。 类：实现爆炸的初始化。绘制功能，爆炸效果由绘制半径从小到大再到小的圆实现。 类：包含枚举。 类：用于实现血包的功能。 三、功能实现。 一．绘制地图功能： public class TankMap extends Frame{ tart(); }
制坦克功能：public class Tank { 方坦克的绘制方法 public class EnemyTank extends Tank{ 弹绘制方法public class Shell { ntersects())){
ntersects())){ "hittanks"); (false); =false; Explor ex=new Explor(x-3,y-3,; return true; } } return true; } }
基于java的游戏坦克大战论文
基于j a v a的游戏坦克 大战论文 文件排版存档编号：[UYTR-OUPT28-KBNTL98-UYNN208]
目录 1 2 5 1
第一章绪论 课题研究的背景 如今我们的生活节奏越来越快，每个人的生活压力也在不断变大，长期紧绷着神经容易产生心理和生理上的双重伤害，人们需要在工作和学习之外放松自己，玩玩游戏正是放松自己的方式之一。 坦克大战，一个众所周知的小游戏，曾经在红白机时代风靡一时。其界面简单，耐玩，关卡多，可玩性高，没有局限的年龄层。 Java是现在全球最时髦的开发工具之一，它拥有庞大且完善的类库，内置了其他语言需要靠库甚至是操作系统才能支持的功能，拥有一个虚拟机，总之，Java的出现，确实给整个程序界带来了巨大的冲击，也许现在还无法准确评估Java为整个IT业带来的影响，但是有一点毋庸置疑—Java将不可避免的影响一带程序员。 使用Java作为开发工具，来做坦克大战这个小游戏，是一种很理性的选择。Java游戏可以在本地桌面系统下运行，也可以在Web浏览器下运行。 我在大学四年中学到了很多计算机的知识，JAVA语言，软件工程，数据结构，软件工程等课程。如今我将用我所学的知识来完成一个坦克大战游戏，来锻炼自己的动手能力，独立作出一个小程序。 课题研究的任务 本文中所做的主要工作如下： （1）介绍了制作坦克大战游戏的意义和目的。 （2）设计坦克大战游戏各个类，实现各类效果和目标。 （3）分析并解决游戏中的若干技术问题。 （4）完成坦克大战游戏，进行测试并分析结果.
第二章系统分析 课题的可行性分析 1、课题要求 （1）与实践活动和相关的文件和资料由教师提供。 （2）本课题要求学生有熟练的Java开发能力，有较强的自学能力。 （3）具体问题再做详细调查研究并与指导老师面谈。 2、可行性分析 技术可行性：游戏对机器没有多大要求，现在无论什么电脑，只要能安装J2SDK，就能在电脑上开发这款游戏。制作出来的游戏可以在本地桌面运行，也可在WEB上运行，现在JAVA语言非常成熟，完全能够完成这个游戏。 经济可行性：开发这个游戏除了耗费自己的时间和精力以外，不需要其他的资金问题，完成后放到网上开放下载，无需任何费用，有兴趣的人可以自己下载来玩。 需求分析 在游戏中需要实现的功能： （1）能够通过键盘自由控制坦克移动和发射子弹； （2）敌方坦克能够随机移动和随机发射子弹； （3）子弹和不同阵营坦克碰撞后会产生爆炸； （4）消灭敌方坦克后会有个计分板记录玩家得分 （5）游戏进行到一半时可以暂停退出，下次打开游戏时选继续游戏可以继续之前的游戏。 第三章系统总体设计 游戏总体流程设计 开始新游戏时，先进行初始化，然后调用敌方坦克类和我方坦克类，实现键盘监听功能，战场显示所有坦克的移动，发射子弹。判断子弹和敌方坦克的碰撞，调用爆炸类，调用记录类，修改玩家总得分。
java开发坦克大战
j a v a开发坦克大战 IMB standardization office【IMB 5AB- IMBK 08- IMB 2C】
坦克大战游戏演示为什么选择这个项目 1、好玩 2、涉及到java各个方面的技术 1、java面向对象编程； 2、界面编程； 3、绘图技术； 4、多线程； 5、文件i/o操作； 6、数据库 3、巩固旧知识，学习新知识 java绘图坐标体系 绘图坐标本系--介绍 坐标原点位于左上角，以像素为单位。像素是计算机屏幕上最小的显示单位。在java的坐标系中，第一个是X坐标，表示当前位置为水平方向，距离坐标原点X个像素；第二个是Y坐标，表示当前位置为垂直方向，距离坐标原点Y个像素。 坐标体系--像素 计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行，整个计算机屏幕共有480000个像素。现在的计算机可以支持更高的分辨率，也就是说，屏幕上可以显示更多的像素。因此，像素是一个密度单位，而厘米是长度单位，两者无法比较。 绘图原理(1)[] Component类提供了两个和绘图相关最重要的方法： 1、paint(Graphicsg)绘制组件的外观 2、repaint()刷新组件的外观
当组件第一次在屏幕显示的时候，程序会自动的调用paint()方法来绘制组件 .*; .*; publicclassWindow013extendsJFrame{ ; 7、画字符串drawString(Stringstr,intx,inty); 8、设置画笔的字体setFont(Fontfont); 9、设置画笔的颜色setColor(Colorc); ; .*; publicclassWindow014extendsJFrame{ ; .*; publicclassWindow015extendsJFrame{ ; .*; import publicclassWindow016extendsJFrameimplementsActionListener{ quals("黑色")){ 点击了黑色按钮"); ; }elseif().equals("红色")){ 点击了红色按钮"); ; }else{ 不知道"); } } } classCatimplementsActionListener{ publicvoidactionPerformed(ActionEventarg0){ if().equals("黑色")){ 也知道你按下了黑色按钮");
马士兵坦克大战经典源代码
package com.bjsxt.tank; import java.awt.*; import java.awt.event.*; import java.util.List; import java.util.ArrayList; /** * 这个类的作用是坦克游戏的主窗口 * @author mashibing * */ public class TankClient extends Frame { /** * 整个坦克游戏的宽度 */ public static final int GAME_WIDTH = 800; public static final int GAME_HEIGHT = 600; Tank myTank = new Tank(50, 50, true, Tank.Direction.STOP, this); Wall w1 = new Wall(100, 200, 20, 150, this), w2 = new Wall(300, 100, 300, 20, this); List
java开发坦克大战
坦克大战游戏演示 为什么选择这个项目 1、好玩 2、涉及到java各个方面的技术 1、java面向对象编程； 2、界面编程； 3、绘图技术； 4、多线程； 5、文件i/o操作； 6、数据库 3、巩固旧知识，学习新知识 java绘图坐标体系 绘图坐标本系--介绍 坐标原点位于左上角，以像素为单位。像素是计算机屏幕上最小的显示单位。在java 的坐标系中，第一个是X坐标，表示当前位置为水平方向，距离坐标原点X个像素；第二个是Y坐标，表示当前位置为垂直方向，距离坐标原点Y个像素。 坐标体系--像素 计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行，整个计算机屏幕共有480000个像素。现在的计算机可以支持更高的分辨率，也就是说，屏幕上可以显示更多的像素。因此，像素是一个密度单位，而厘米是长度单位，两者无法比较。 绘图原理(1)[Window013.java] Component类提供了两个和绘图相关最重要的方法： 1、paint(Graphics g)绘制组件的外观 2、repaint()刷新组件的外观 当组件第一次在屏幕显示的时候，程序会自动的调用paint()方法来绘制组件 import java.awt.*; import javax.swing.*; public class Window013 extends JFrame{ //定义组件 MyPanel mp=null; public static void main(String[] args) { Window013 th=new Window013();
java坦克大战毕业设计论文
基于J2SE的网络版坦克大战游戏设计 摘要 [摘要]：J2SE (Java 2 Standard Edition)就是Java2的标准版，主要用于桌面应用软件的编程，是伴随着计算机技术的飞速发展而诞生的一项新的开发技术。随着个人电脑的日益普及、Java 功能在个人电脑上的实现，Java应用程序产生的单机增值服务逐渐体现出其影响力，对丰富人们的生活内容、愉悦身心、开发智力等起着不可忽视的作用。该论文通过总结和分析JA V A 游戏的开发流程和代码框架的设计，开发了一款基于J2SE架构的游戏——坦克大战。本设计采用面向对象的设计模式，对游戏中的所有物体赋予对象的概念和属性。运行程序后允许用户选择执行选项菜单。在开始游戏后，启动服务器和客户端，对背景的所有物体进行绘图。在主程序运行的线程中，画面刷新将以一定的频率采用双缓冲技术对屏幕重绘，实时反映整个游戏的进行状态。用户控制的坦克运行在主线程中，随屏幕刷新的频率而移动。坦克将在游戏开始时进行初始化，然后将坦克绘制在地图的上层。本设计主要实现的功能是让坦克能向八个方向移动，并且打出炮弹，子弹击中敌人坦克，子弹和敌人坦克同时消失，产生爆炸，CPU坦克能智能的移动并且打出炮弹。能够支持网络对战和单机对战两种模式。 Java良好的跨平台特性在软件的开发中显示出了巨大的威力，“一次编写，随处运行”，java 系统可以运行在不同的操作系统和硬件上。随着linux的持续增长以及MacOSX完全支持java 技术，跨平台的特性变得越来越有分量。 由于免费、跨平台、java语言本身技术先进，在高校中，java已经成为许多学科研究、课程和计算的首选语言，用java做上机作业，一般都是鼓励的。据我所知，北大、清华许多院系的研究生入学考试都可以用java语言答题。实际上，用java来完成这些工作，大多数情况下要比用C或其他语言简洁得多，你可以把注意力集中在算法等核心部分，从而获得更高分数。 [关键词] 面向对象坦克大战游戏J2SE Socket
坦克大战java源代码
有些图片路径会出错要注意package com.tankgame; import java.util.Vector; //坦克类 class Tank { int x=0; int y=0; int color=0; int speed=1; int direct=0; boolean isLive=true; public Tank(int x,int y) { this.x=x; this.y=y; } public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public int getDirect() { return direct; } public void setDirect(int direct) { this.direct = direct;
} public int getColor() { return color; } public void setColor(int color) { this.color = color; } } //我的坦克 class Hero extends Tank { Shot shot=null; Vector
毕业设计论文 基于J2ME的Java游戏--坦克大战的开发
目录 摘要 ................................................................................................................... - I - Abstract .................................................................................................................... - I - 引言 ...................................................................................................................... II 第一章绪论 .................................................................................................... - 1 - 1.1 手机软件现状.......................................................................................... - 1 - 1.2 游戏业务及J2ME概况............................................................................ - 1 - 1.3 任天堂(Nintendo)的8位FC机器和Battle City背景介绍............ - 3 - 1.4 本章小结.................................................................................................. - 3 - 第二章开发环境及相关技术的介绍 ................................................................ - 5 - 2.1 开发环境.................................................................................................. - 5 - 2.2 Java语言的特点..................................................................................... - 5 - 2.3 关于JBuilder9....................................................................................... - 5 - 2.4 关于Wireless Tool Kit....................................................................... - 6 - 2.5 Java Appication Manager.................................................................... - 6 - 2.6 本章小结.................................................................................................. - 6 - 第三章程序结构、思想和相关技术 ................................................................ - 7 - 3.1 本程序需解决的有关技术问题.............................................................. - 7 - 3.2 程序流程.................................................................................................. - 8 - 3.3 绘图与MIDP2.0新增的GameCanvas包.............................................. - 10 - 3.3.1 提供低级绘制的Canvas类....................................................... - 10 - 3.3.2 Graphics类................................................................................ - 10 - 3.3.3 PNG格式...................................................................................... - 10 - 3.3.4 Game包中的新功能.................................................................... - 11 - 3.3.5 有关绘图的一些技术................................................................. - 12 - 3.4 坦克的控制和敌方的智能运行............................................................ - 12 - 3.5 子弹的运行和控制................................................................................ - 13 - 3.6 RMS数据库系统..................................................................................... - 14 - 3.7 内存使用的最佳化................................................................................ - 15 - 3.8 混淆器(Obfuscator)的使用................................................................ - 16 - 3.9 模拟器的相关调试................................................................................ - 16 - 3.10 本章小结.............................................................................................. - 17 - 第四章程序分析和具体实现 .............................................................................. - 18 - 4.1 游戏进入前的选择................................................................................ - 18 - 4.2 主游戏逻辑及其涉及到的若干类........................................................ - 19 - 4.3 坦克的共同行为.................................................................................... - 21 - 4.4 玩家坦克的功能属性............................................................................ - 22 - 4.5 敌人坦克的功能属性............................................................................ - 22 - 4.6 子弹的运行和控制................................................................................ - 24 - 4.7 记分系统................................................................................................ - 25 -
java写的坦克大战简易版
MyTankGame2.java package test; import javax.swing.*; import java.awt.*; import java.awt.event.*; //import java.io.*; import java.util.*; class MyTankGame2 extends JFrame implements ActionListener { MyPanel mp=null; //定义一个开始的面板 MyStartPanel msp=null; //做出我需要的菜单 JMenuBar jmb=null; //开始游戏 JMenu jm1=null; JMenuItem jmi1=null; //退出系统 JMenuItem jmi2=null; //存盘退出 JMenuItem jmi3=null; JMenuItem jmi4=null; public static void main(String[] args) { //System.out.println("Hello World!"); MyTankGame2 mtg=new MyTankGame2(); } //构造方法 public MyTankGame2() { //创建菜单及菜单选项 jmb=new JMenuBar(); jm1=new JMenu("游戏（G）"); //设置助记符 jm1.setMnemonic('G'); jmi1=new JMenuItem("开始新游戏（N）"); jmi2=new JMenuItem("退出游戏(E)"); jmi3=new JMenuItem("存盘退出游戏"); jmi4=new JMenuItem("继续上局游戏"); jmi4.addActionListener(this);
坦克大战系统《Java程序开发实训》综合实训报告
《Java程序开发实训》综合实训报告 题目：坦克大战系统 姓名：方庆 学号：2010203206 班级：10软件（2）班
一、系统实现的主要功能及运行结果截图 选择的语言的原因 游戏本身是一种娱乐方式，带给人无尽的乐趣，而且游戏行业的发展也将是带动周边行业的发展。同样对做出游戏的人的要求也会越来越高一满足游戏爱好者的要求。本次期末设计就是设计一种娱乐性较强的小游戏坦克大战，说到大战其实是不敢当的。但游戏基本拥有可玩性。java语言是一种跨平台，适合与分布计算环境的面向对象编程语言，java主要用在web开发，手机游戏及一些平台游戏的开发，他有很好的跨平台性。所以本次的设计坦克游戏选择的是java。 系统软件的软件环境 1.网络服务器操作系统：Window是 XP以上 2.开发工具：Eclipse 3运行环境：J2sdk 4.编程语言：java语言。 人机对战模式功能 1.能够发射子弹打击敌人 2.敌人能够移动 3.能够模拟爆炸 4.能够产生障碍 5能够增长生命6.能够使用超级子弹 坦克可以发射子弹
玩家坦克被击中血量减少。 被击中的坦克发生爆炸并且吃血块可以加血量。
玩家坦克可以从把方向发射超级子弹 自己的TankHealth为<=0时，。说明玩家坦克已死亡。游戏结束
本系统的坦克大战是基于java语言设计的开发，具有较高的人工智能和相对的图形处理。游戏可一人作战每次电脑方有10辆坦克， 此一举消灭全部的敌方坦克为目的。在这过程中坦克有机会得到血块来添加自己的生命值。从而变得强大。也利用wall来形成阻击敌人。 游戏拥有开挂的功能。可以穿过墙体来攻击敌方坦克。还给玩家坦克 置了超级炮弹。从八个方向同时射出炮弹来摧毁敌方坦克。主要功能 简单罗列如下： 1.屏幕左上方显示游戏的状态，当玩家方坦克全数为0是游戏结束 2.敌方坦克只在空地上行走，不可通过Wall 3.游戏打坏敌方坦克后，可随机位置随机出现血块奖励。坦克经过该 位置可获得相应的生命值加成。 4.玩家坦克的游戏资格和电脑坦克不同。 TankClient类设计流程 游戏系统类关联图
基于Java的网络版坦克大战游戏设计_毕业设计
伊犁师范学院 本科生毕业论文（设计） 论文题目：基于Java的网络版坦克大战游戏设计
基于Java的网络版坦克大战游戏设计 （伊犁师范学院计算机科学系06-2班，新疆伊宁市 835000） 摘要：本设计采用面向对象的设计模式，对游戏中的所有物体赋予对象的概念和属性。运行程序后允许用户选择执行选项菜单。在开始游戏后，启动服务器和客户端，对背景的所有物体进行绘图。在主程序运行的线程中，画面刷新将以一定的频率采用双缓冲技术对屏幕重绘，实时反映整个游戏的进行状态。用户控制的坦克运行在主线程中，随屏幕刷新的频率而移动。坦克将在游戏开始时进行初始化，然后将坦克绘制在地图的上层。本设计主要实现的功能是让坦克移动并能够智能的打出炮弹，躲避子弹，炸毁对方坦克。能够支持网络对战和单机对战两种模式。 关键词：面向对象；坦克大战；网络游戏；Java；Socket 类 中图分类号：TP311.1 目录
摘要 ......................................................................... 第1章前言.. (1) 1.1游戏设计的需求分析 (1) 1.1.1国内外电子网络游戏的现状 (1) 1.1.2本系统的现实意义 (1) 1.1.3本系统和其他开发游戏区别 (2) 1.2开发技术概述 (2) 1.2.1J AVA、C语言、C++三种主流编程技术比较 (2) 1.3本章小结 (2) 第2章相关技术理论 (3) 2.1系统运行环境 (3) 2.1.1系统运行的软件环境 (3) 2.1.2系统运行的硬件环境 (3) 2.2相关理论 (3) 2.2.1关于E CLIPSE的介绍 (3) 2.2.2J2SE框架 (3) 2.2.3联机通信机制 (4) 2.2.4J AVA图形编程 (5) 2.3本章小结 (5) 第3章系统设计 (5) 3.1系统可行性分析 (6) 3.1.1技术可行性 (6) 3.1.2经济可行性 (6) 3.1.3操作可行性 (6) 3.2系统需求分析 (6) 3.2.1在人机对战模式下实现的功能 (6) 3.2.2在网络对战模式下实现的功能 (6) 3.3系统功能设计 (6) 3.3.1坦克大战总体功能设计 (7)
基于java坦克大战课程设计
摘要 面向对象方法是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，它吸取了结构化程序设计的精华，以更接近人们通常思维的方式来处理问题，是一种全新的软件开发技术。 作为一种新的的编程语言，Java很大程度推广了面向对象的思想。随着计算机技术的发展，Java的强大展现出它不可替代的作用。Java的功能不仅体现在它网络方面的应用，对于应用程序设计、游戏设计等Java都能满足需求。 本文针对Java 的具体应用，设计了一个小游戏。根据游戏的规则，用户将可以和计算机进行简单对战。程序实现了友好的用户交互界面，让用户能很好地对游戏进行操作。 关键字：JAVA GUI 游戏 ABSTRACT The Object-Oriented Method is a method which apllies the Object-Oriented Design to the process of the software exploiture and directs the ploy of development. It extracts the prime of the Structured Design for Computer Programmers, deals matters with a folksy fashion, which is considered to be a grand new software-develop technique. As a new programming language, Java spread the Object-Oriented Design in a certain degree. With the development of the technique of computer, the insurmountable function of JAVA is exhibited for its’ mightiness. Not only applies in network, JAVA also can fulfill the requirement of the Application-Design and Game-Design. In this paper, to use the idiographic application of JAVA , I design a game called . Following the regular of the game, user can play a simple revalry with computer. This programme actualizes a folksy GUI mode, which will make user master game easily. Keywords: JAVA GUI Game
JAVA课程设计坦克大战游戏(含代码)
Java课程设计 任务书 简单电子游戏坦克大战的设计 1、主要内容： 设计一个简单的坦克大战电子游戏，可以允许多位玩家在局域网 中同时对战 2、系统要求：游戏具有图形游戏界面，能让用户看到游戏所给出的反馈。有人机交互功能，使用户操作指定的游戏元素，并且坦克具有生命值，能攻击敌方，无法攻击友方，而且坦克的攻击具有视觉效果！ 3、具体要求（包括技术要求等）： 1.需要有图形游戏界面，让用户能看到游戏给出的反馈 2.有人机交互功能，使用户能操作指定的游戏元素 3.不同队伍的坦克，须显示不同外观，已分辨敌我 4.坦克能够开火，攻击敌方，但不能攻击队友 5需要有不可被子弹穿透的墙 6.坦克有生命值，并非被击中一次就会爆炸 7游戏结束后可重新开始 学习并掌握以下技术：Java、JavaBean 等 熟练使用以下开发工具：Myeclipse 等 实现系统上述的功能。 4、进度安排： 12月28日~ 12月29日：课程设计选题，查找参考资料 12月30日~ 1月1日：完成系统设计和数据库设计 1月2日~ 1月4日：完成程序代码的编写 1月4日~ 1月5日：系统测试与完善 1月5日~ 1月6日：完成课程设计报告，准备答辩 分工：
随着计算机的普及以及对电子游戏的认识，电子游戏已被越来越多的人选作放松、娱乐的休闲方式；电子游戏既不需要专门购买游戏器材，也不需要宽阔的游戏场地，只需要一台能独立完成任务的计算机即可，它可以是人们工作、学习时用的计算机，并不需要另行配置，这比起传统休闲游戏即省钱又省事。局域网游戏更是可以将现实空间中零散的计算机，组织起来，使其在逻辑空间中集中起来，使游戏的组织、开展变得轻松。如此轻松而又安逸的休闲方式，使得越来越多的人尝试，甚至已经将电子游戏作为主要休闲方式，既然有如此多的人使用，那其中必然存在巨大的商机，即使人们不愿意为一个小小的休闲游戏花费金钱，但在游戏中添加广告、游戏相关服务也包藏了巨大的财富；当然电子游戏的制作如今已是空前的火爆，大大小小的游戏公司横空出世，都想在电子游戏制作这个行业里占据一席之地，而一款成功的电子游戏需要精心的策划、分析、设计，只有这样才能获得游戏中包藏的财富，以及做出一款真正能够让玩家娱乐、放松的游戏，而不是骗取玩家钱财的工具。 关键字：电子游戏；坦克大战；
java实现坦克大战课程设计
Java实现坦克大战小游戏 摘要 Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。我的课程设计是用java来做一个简单的坦克大战小游戏。我将这个程序细分了多个部分，每个部分都建了独立的类，比如：坦克的模型类，河道，树和坦克方向等等。之所以将之细分，是遵循了java的万事万物皆对象的原理。在实现每个类时，最简单但也是最繁琐就是建立界面与实例化坦克，因为这牵扯了界面布局，监听的建立等；而有一些类，比如;河道、墙、坦克，这些类这可以依样画葫芦的编写。 在编写过程，借鉴了他人的一些图片模型，实现的功能也并不是和经典的FC坦克大战相同，但是每个坦克之间的互动还是实现了的。 关键词：万事万物皆对象界面布局坦克之间的互动
USE JA V A TO REALIZE BATTLE CITY MINI-GAME ABSTRACT Java is a object oriented program design language what can compose cross platform application software. My curriculum design is using JA V A language to make a simple small game called Tank Battle. I break down this program into multiple parts, each part is to establish an independent class, such as: Tank Model class, River Course class, Tree class, The Direction of Tank class and so on. The reason divides into multiple parts, is because follow the principle of JA V A that everything is an object. When implements every class, the most simple but also the most troublesome is build interface and instantiate Tank class, because it is involved of the interface layout, monitoring the establishment. While there are some classes, such as: River Course class, Wall class and Tank class, can write like stick closely to the pattern given. In the preparation process, I refer some pictures of models of others, the function of the retaliate isn’t like FC Tank Battle, but the interaction between ach tank is realized. Key words: everything is an object, the interface layout, the interaction between each tank
- java 坦克大战游戏教程完整代码
- java开发坦克大战
- JAVA语言写的坦克大战详细说明书
- java关于坦克大战的课程设计报告
- Java面向对象程序设计与系统开发第十章网络坦克大战游戏制作第一讲 面向对象游戏设计(1)
- JAVA语言写的坦克大战详细说明书
- java坦克大战课程设计报告
- java坦克大战毕业设计论文
- java实现坦克大战课程设计
- JAVA 坦克大战中的子弹代码 Tank
- java坦克大战毕业设计
- java课程设计--坦克大战游戏(带源码)
- 坦克大战JAVA源代码
- 基于Java的网络版坦克大战游戏设计_毕业设计
- Java综合编程——坦克大战(15.1.5)分析
- java写的坦克大战简易版
- Java坦克大战设计报告
- JAVA关于坦克大战的课程设计报告
- JAVA课程设计坦克大战游戏(含代码)
- java 坦克大战PPT