`

Java笔记6(多线程、机票售票系统、坦克大战)

    博客分类：
  • Java
 
阅读更多 
多线程Demo10_1.java 

/* 

* 演示如果通过继续Thread来开发线程 

*/ 

/* 

* 在java中一个类要当作线程来使用有两种方法： 

* 1.继承Thread类，并重写run函数 

* 2.实现Runable接口，并重写run函数 

*/ 

package com.test1; 

 

public class Demo10_1 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//创建一个Cat对象 

Cat cat=new Cat(); 

//启动线程，会导致run函数的运行 

cat.start(); 

} 

} 

 

class Cat extends Thread 

{ 

int times=0; 

//重写run函数 

public void run() 

{ 

while(true) 

{ 

try { 

//休眠一秒 

Thread.sleep(1000); 

//1000表示1000毫秒，sleep就会让该线程进入Blocked状态，并释放资源 

} catch (InterruptedException e) { 

 

e.printStackTrace(); 

} 

times++; 

System.out.println("Hello World "+times); 

if(times==10) 

{ 

//退出 

break; 

} 

} 

} 

} 

多线程Demo10_2.java 

/* 

* 功能：用Runable接口实现多线程 

*/ 

 

package com.test2; 

 

public class Demo10_2 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//注意启动------------------------------------------- 

Dog dog=new Dog(); 

//创建一个Thread对象 

Thread t=new Thread(dog); 

t.start(); 

//--------------------------------------------------- 

} 

 

} 

 

class Dog implements Runnable 

{ 

int times=0; 

public void run() 

{ 

while(true) 

{ 

try { 

//休眠一秒 

Thread.sleep(1000); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

times++; 

System.out.println("Hello "+times); 

if(times==10) 

{ 

//退出 

break; 

} 

} 

} 

} 

多线程Demo10_3.java 

/* 

* 功能：两个线程同时运行的案例 

*/ 

 

package com.test3; 

 

public class Demo10_3 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//创建一个Pig和一个bird 

Pig pig=new Pig(10); 

Bird bird=new Bird(10); 

Thread t1=new Thread(pig); 

Thread t2=new Thread(bird); 

t1.start(); 

t2.start(); 

} 

} 

 

//打印 

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 (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

times++; 

System.out.println("pig是一个线程，在输出第"+times+"个Hello World!"); 

if(times==n) 

{ 

break; 

} 

} 

} 

} 

 

 

//算数学题 

class Bird implements Runnable 

{ 

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 (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

res+=(++times); 

System.out.println("当前结果是："+res); 

if(times==n) 

{ 

System.out.println("最后结果是："+res); 

break; 

} 

} 

} 

} 

坦克大战v3.0_ MyTankGame2.java 

/* 

* 功能：坦克大战v3.0 

* 1.画出坦克 

* 2.我的坦克可以上下左右移动 

* 3.敌人的坦克及子弹可以自由移动 

*/ 

 

package com.test4; 

import java.awt.*; 

import javax.swing.*; 

 

import java.awt.event.*; 

import java.util.*; 

 

public class MyTankGame2 extends JFrame{ 

 

MyPanel mp=null; 

 

//构造函数 

public MyTankGame2() 

{ 

mp=new MyPanel(); 

 

//启动mp线程 

Thread t=new Thread(mp); 

t.start(); 

this.add(mp); 

 

//注册监听 

this.addKeyListener(mp); 

 

this.setSize(400,300); 

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

this.setVisible(true); 

} 

 

public static void main(String[] args) { 

MyTankGame2 mtg=new MyTankGame2(); 

} 

 

} 

 

//我的面板 

class MyPanel extends JPanel implements KeyListener,Runnable 

{ 

//定义一个我的坦克 

Hero hero=null; 

 

//定义敌人的坦克组 

Vector<EnemyTank>ets=new Vector<EnemyTank>(); 

 

int enSize=3; 

 

//构造函数 

public MyPanel() 

{ 

hero=new Hero(100,200); 

 

//初始化敌人的坦克 

for(int i=0;i<enSize;i++) 

{ 

//创建一个辆敌人的坦克对象 

EnemyTank et=new EnemyTank((i+1)*50,0); 

et.setColor(0);//设置颜色 

et.setDirect(2); 

//加入 

ets.add(et); 

 

} 

} 

 

//重写paint函数 

public void paint(Graphics g) 

{ 

super.paint(g); //这句不能少 

g.fillRect(0,0,400,300);//设置游戏面板背景 

 

//画出自己的坦克 

this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); 

 

//画出子弹 

if(hero.s!=null&&hero.s.isLive==true) 

{ 

g.setColor(Color.WHITE);//设置子弹颜色 

g.fill3DRect(hero.s.x, hero.s.y, 3, 3, true); 

} 

 

//画出敌人的坦克 

for(int i=0;i<ets.size();i++) 

{ 

this.drawTank(ets.get(i).getX(), ets.get(i).getY(), g, ets.get(i).getDirect(), 0); 

} 

} 

 

//画出坦克的函数(扩展) 

public void drawTank(int x,int y,Graphics g,int direct,int type) 

{ 

//判断坦克的类型 

switch(type) 

{ 

case 0: 

g.setColor(Color.cyan); 

break; 

case 1: 

g.setColor(Color.yellow); 

break; 

} 

 

//判断方向 

switch(direct) 

{ 

case 0: //向右 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x+30, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 1: //向左 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 2: //向下 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y+30); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

case 3: //向上 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

} 

} 

 

@Override 

public void keyPressed(KeyEvent e) //键按下处理 

{ 

//a表示向左，s表示向上，w表示向上，d表示向右 

if(e.getKeyCode()==KeyEvent.VK_D) 

{ 

this.hero.setDirect(0);//设置我的坦克的方向,向右 

this.hero.moveRight(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_A) 

{ 

this.hero.setDirect(1);//向左 

this.hero.moveLeft(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_S) 

{ 

this.hero.setDirect(2);//向下 

this.hero.moveDown(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_W) 

{ 

this.hero.setDirect(3);//向上 

this.hero.moveUp(); 

} 

 

if(e.getKeyCode()==KeyEvent.VK_J) 

{ 

//判断玩家是否按下j 

//发射子弹 

this.hero.shotEnemy(); 

} 

//重绘Panel 

this.repaint(); 

} 

 

@Override 

public void keyReleased(KeyEvent e) 

{ 

 

} 

 

@Override 

public void keyTyped(KeyEvent e) 

{ 

 

} 

 

@Override 

public void run() { 

//每隔100毫秒去重绘 

while(true) 

{ 

try { 

Thread.sleep(100); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

//重绘 

this.repaint(); 

} 

 

} 

} 

Members.java 

package com.test4; 

 

//子弹类 

class Shot implements Runnable 

{ 

int x,y,direct; 

int speed=3; 

//是否还活着 

boolean isLive=true; 

 

public Shot(int x,int y,int direct) 

{ 

this.x=x; 

this.y=y; 

this.direct=direct; 

} 

 

@Override 

public void run() { 

//子弹向前跑动 

while(true) 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

switch(direct) 

{ 

case 0: //子弹向右 

x+=speed; 

break; 

case 1: //子弹向左 

x-=speed; 

break; 

case 2: //子弹向下 

y+=speed; 

break; 

case 3: //子弹向上 

y-=speed; 

break; 

} 

System.out.println("子弹坐标x="+x+" y="+y); 

 

//子弹何时死亡 

//判断该子弹是否碰到边缘 

if(x<0||x>400||y<0||y>300) 

{ 

this.isLive=false; 

break; 

} 

} 

} 

} 

 

 

//坦克类 

class Tank 

{ 

//表示坦克的横坐标 

int x=0; 

//坦克纵坐标 

int y=0; 

//坦克方向 

int direct=0;//0表示右，1表示左，2表示下，3表示上 

//坦克的速度 

int speed=1; 

//坦克的颜色 

int color; 

 

public int getColor() { 

return color; 

} 

 

public void setColor(int color) { 

this.color = color; 

} 

 

public int getSpeed() { 

return speed; 

} 

 

public void setSpeed(int speed) { 

this.speed = speed; 

} 

 

public int getDirect() { 

return direct; 

} 

 

public void setDirect(int direct) { 

this.direct = direct; 

} 

 

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 Tank(int x,int y) 

{ 

this.x=x; 

this.y=y; 

} 

 

} 

 

//敌人的坦克 

class EnemyTank extends Tank 

{ 

public EnemyTank(int x,int y) 

{ 

super(x,y); 

} 

} 

 

//我的坦克 

class Hero extends Tank 

{ 

//子弹 

Shot s=null; 

 

public Hero(int x,int y) 

{ 

super(x,y);//用父类的构造函数初始化子类的成员变量 

} 

 

//发射子弹 

public void shotEnemy() 

{ 

switch(this.direct) 

{ 

case 0: //坦克朝右 

s=new Shot(x+30,y+9,0); 

break; 

case 1: //坦克朝左 

s=new Shot(x,y+9,1); 

break; 

case 2: //坦克朝下 

s=new Shot(x+9,y+30,2); 

break; 

case 3: //坦克朝上 

s=new Shot(x+9,y,3); 

break; 

} 

//启动子弹线程 

Thread t=new Thread(s); //因为子弹类Shot实现了Runnable接口 

t.start(); 

} 

 

//坦克向上移动 

public void moveUp() 

{ 

y-=speed; 

} 

//坦克向右移动 

public void moveRight() 

{ 

x+=speed; 

} 

//坦克向下移动 

public void moveDown() 

{ 

y+=speed; 

} 

//坦克向左移动 

public void moveLeft() 

{ 

x-=speed; 

} 

} 

线程的注意事项_Demo11_1.java 

/* 

* 功能：演示使用线程的注意事项 

*/ 

 

package com.test1; 

 

public class Demo11_1 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//启动线程 

Cat cat1=new Cat(); 

cat1.start(); 

//cat1.start();//一个线程类只能启动一次 

 

Dog dog1=new Dog(); 

Thread t=new Thread(dog1); 

Thread t2=new Thread(dog1); 

t.start(); 

t2.start(); 

//t2.start();//一个线程类只能启动一次 

 

//结论：不管是通过继承Thread,还是通实现Runnable接口创建线程， 

//它们的一个对象只能启动一次，否则就会有异常抛出。 

} 

 

} 

 

//猫类 

class Cat extends Thread 

{ 

public void run() 

{ 

System.out.println("11"); 

} 

} 

 

//狗类 

class Dog implements Runnable 

{ 

 

@Override 

public void run() { 

System.out.println("22"); 

 

} 

 

} 

机票售票系统Demo11_2.java 

/* 

* 功能：模拟一个机票售票系统：有三个售票点， 

* 在1天卖出2000张票。（注是一共有2000张票） 

*/ 

 

package com.test2; 

 

public class Demo11_2 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//定义三个售票窗口 

TicketWindow tw1=new TicketWindow(); 

//TicketWindow tw2=new TicketWindow(); 

//TicketWindow tw3=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 

{ 

//一共两千张票 

private static int nums=2000; 

//private Dog myDog=new Dog(); 

 

public void run() 

{ 

while(true) 

{ 

//认为if else 要保证其原子性[同步代码块] 

//synchronized(myDog) //对象锁，保证同步安全 

synchronized(this) 

{ 

//先判断是否还有票 

if(nums>0) 

{ 

System.out.println(Thread.currentThread().getName()+" 在售出第"+nums+"张票"); 

nums--; 

 

//出票速度是1秒出一张 

try { 

Thread.sleep(1000); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

else 

{ 

//售票结束 

break; 

} 

} 

} 

} 

} 

 

class Dog 

{ 

 

} 

 

坦克大战v3.0优化版_ MyTankGame2.java 

/* 

* 功能：坦克大战v3.0 

* 1.画出坦克 

* 2.我的坦克可以上下左右移动 

* 3.可以发射子弹，子弹连发(最多5颗) 

* 4.当子弹击中敌人坦克时，敌人坦克消失(爆炸效果) 

* 5.我被击中时，显示爆炸效果 

*/ 

 

package com.test3; 

import java.awt.*; 

 

import javax.imageio.ImageIO; 

import javax.swing.*; 

 

import java.awt.event.*; 

import java.util.*; 

import java.io.*; 

 

public class MyTankGame2 extends JFrame{ 

 

MyPanel mp=null; 

 

//构造函数 

public MyTankGame2() 

{ 

mp=new MyPanel(); 

 

//启动mp线程 

Thread t=new Thread(mp); 

t.start(); 

this.add(mp); 

 

//注册监听 

this.addKeyListener(mp); 

 

this.setSize(400,300); 

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

this.setVisible(true); 

} 

 

public static void main(String[] args) { 

MyTankGame2 mtg=new MyTankGame2(); 

} 

 

} 

 

//我的面板 

class MyPanel extends JPanel implements KeyListener,Runnable 

{ 

//定义一个我的坦克 

Hero hero=null; 

 

//定义敌人的坦克组 

Vector<EnemyTank>ets=new Vector<EnemyTank>(); 

 

//定义zhadan集合 

Vector<Bomb>bombs=new Vector<Bomb>(); 

 

//初始化敌人坦克数量 

int enSize=3; 

 

//定义三张图片，组成成一个zhadan

Image image1=null; 

Image image2=null; 

Image image3=null; 

 

//构造函数 

public MyPanel() 

{ 

hero=new Hero(100,200); 

 

//初始化敌人的坦克 

for(int i=0;i<enSize;i++) 

{ 

//创建一个辆敌人的坦克对象 

EnemyTank et=new EnemyTank((i+1)*50,0); 

et.setColor(0);//设置颜色 

et.setDirect(2); 

//启动敌人的坦克 

Thread t=new Thread(et); 

t.start(); 

//给敌人坦克添加一颗子弹 

Shot s=new Shot(et.x+10,et.y+30,2); 

//把子弹加入给敌人 

et.ss.add(s); 

//启动子弹敌人的子弹线程 

Thread t2=new Thread(s); 

t2.start(); 

//加入 

ets.add(et); 

 

} 

try{ 

image1=ImageIO.read(new File("./src/bomb_1.gif")); 

image2=ImageIO.read(new File("./src/bomb_2.gif")); 

image3=ImageIO.read(new File("./src/bomb_3.gif")); 

}catch (Exception e) 

{ 

e.printStackTrace(); 

} 

 

 

//初始化图片 

//image1=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_1.gif")); 

//image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_2.gif")); 

//image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_3.gif")); 

} 

 

 

//重写paint函数 

public void paint(Graphics g) 

{ 

super.paint(g); //这句不能少 

g.fillRect(0,0,400,300);//设置游戏面板背景 

 

//画出自己的坦克 

if(hero.isLive) 

{ 

this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); 

} 

//从ss中取出每一颗子弹，并画出 

for(int i=0;i<this.hero.ss.size();i++) //设置子弹连发 

{ 

//取出一颗子弹 

Shot myShot=hero.ss.get(i); 

 

//画出一颗子弹 

if(hero.s!=null&&hero.s.isLive==true) 

{ 

g.setColor(Color.WHITE);//设置子弹颜色 

g.fill3DRect(myShot.x, myShot.y, 3, 3, true); 

} 

if(myShot.isLive==false)//如果子弹已经死亡 

{ 

//从ss中删除掉该子弹 

hero.ss.remove(myShot); 

} 

} 

 

//画出zhadan 

for(int i=0;i<bombs.size();i++) 

{ 

//System.out.println("bombs.size()="+bombs.size()); 

//取出zhadan 

Bomb b=bombs.get(i); 

if(b.life>6) 

{ 

g.drawImage(image1, b.x, b.y, 30, 30, this); 

} 

else if(b.life>4) 

{ 

g.drawImage(image2, b.x, b.y, 30, 30, this); 

} 

else 

{ 

g.drawImage(image3, b.x, b.y, 30, 30, this); 

} 

//让b的生命值减小 

b.lifeDown(); 

if(b.life==0)//如果zhadan生命值为0时，就把zhadan从集合中去掉 

{ 

bombs.remove(b); 

} 

} 

 

//画出敌人的坦克 

for(int i=0;i<ets.size();i++) 

{ 

EnemyTank et=ets.get(i); 

if(et.isLive) //画出还是活的坦克 

{ 

this.drawTank(et.getX(), et.getY(), g, et.getDirect(), 0); 

//再画出敌人的子弹 

for(int j=0;j<et.ss.size();j++) 

{ 

//取出子弹 

Shot enemyShot=et.ss.get(j); 

if(enemyShot.isLive) 

{ 

g.setColor(Color.PINK);//设置子弹颜色 

g.fill3DRect(enemyShot.x, enemyShot.y, 3, 3, true);//画子弹 

} 

else //如果敌人的坦克死亡了就从Vector去掉 

{ 

et.ss.remove(enemyShot); 

} 

} 

} 

 

} 

} 

 

//判断我的子弹是否击中敌人的坦克 

public void hitEnemyTank() 

{ 

//在这run函数里判断子弹是否击中敌人坦克 

for(int i=0;i<hero.ss.size();i++) 

{ 

//取出子弹 

Shot myShot=hero.ss.get(i); 

if(myShot.isLive)//判断子弹是否还是活的或有效 

{ 

//取出每个坦克，与它判断 

for(int j=0;j<ets.size();j++) 

{ 

//取出坦克 

EnemyTank et=ets.get(j); 

if(et.isLive) 

{ 

this.hitTank(myShot,et); 

} 

} 

} 

} 

} 

 

//敌人的子弹是否击中我 

public void hitMe() 

{ 

//取出每一个敌人的坦克 

for(int i=0;i<this.ets.size();i++) 

{ 

//取出坦克 

EnemyTank et=ets.get(i); 

 

//取出每一颗子弹 

for(int j=0;j<et.ss.size();j++) 

{ 

//取出子弹 

Shot enemyShot=et.ss.get(j); 

this.hitTank(enemyShot, hero); 

} 

} 

} 

 

//1.写一个专门判断子弹是否击中敌人坦克的函数 

public void hitTank(Shot s,Tank et) 

{ 

//判断该坦克的方向 

switch(et.direct) 

{ 

//如果敌人坦克的方向是右或者是左 

case 0: 

case 1: 

if(s.x>et.x&&s.x<et.x+30&&s.y>et.y&&s.y<et.y+20) 

{ 

//击中 

s.isLive=false; //子弹死亡 

et.isLive=false;//敌人坦克死亡 

//创建一颗zhadan 

Bomb b=new Bomb(et.x,et.y); 

//把zhadan放入到Vector 

bombs.add(b); 

} 

 

//如果敌人坦克的方向是上或者是下 

case 2: 

case 3: 

if(s.x>et.x&&s.x<et.x+20&&s.y>et.y&&s.y<et.y+30) 

{ 

//击中 

s.isLive=false; //子弹死亡 

et.isLive=false;//敌人坦克死亡 

//创建一颗zhadan 

Bomb b=new Bomb(et.x,et.y); 

//把zhadan放入到Vector 

bombs.add(b); 

} 

} 

} 

 

 

//画出坦克的函数(扩展) 

public void drawTank(int x,int y,Graphics g,int direct,int type) 

{ 

//判断坦克的类型 

switch(type) 

{ 

case 0: 

g.setColor(Color.cyan); 

break; 

case 1: 

g.setColor(Color.yellow); 

break; 

} 

 

//判断方向 

switch(direct) 

{ 

case 0: //向右 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x+30, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 1: //向左 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 2: //向下 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y+30); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

case 3: //向上 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

} 

} 

 

@Override 

public void keyPressed(KeyEvent e) //键按下处理 

{ 

//a表示向左，s表示向上，w表示向上，d表示向右 

if(e.getKeyCode()==KeyEvent.VK_D) 

{ 

this.hero.setDirect(0);//设置我的坦克的方向,向右 

this.hero.moveRight(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_A) 

{ 

this.hero.setDirect(1);//向左 

this.hero.moveLeft(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_S) 

{ 

this.hero.setDirect(2);//向下 

this.hero.moveDown(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_W) 

{ 

this.hero.setDirect(3);//向上 

this.hero.moveUp(); 

} 

 

if(e.getKeyCode()==KeyEvent.VK_J) 

{ 

//判断玩家是否按下j 

//发射子弹 

if(this.hero.ss.size()<=4)//连发子弹小于5 

{ 

this.hero.shotEnemy(); 

} 

} 

//重绘Panel 

this.repaint(); 

} 

 

@Override 

public void keyReleased(KeyEvent e) 

{ 

 

} 

 

@Override 

public void keyTyped(KeyEvent e) 

{ 

 

} 

 

@Override 

public void run() { 

//每隔100毫秒去重绘 

while(true) 

{ 

try { 

Thread.sleep(100); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

 

//2.什么地方调用-判断子弹是否击中敌人坦克的函数 

 

this.hitEnemyTank();//子弹是否击中敌人坦克 

 

this.hitMe();//敌人的坦克是否击中我了 

 

//重绘 

this.repaint(); 

} 

 

} 

} 

Members.java 

package com.test3; 

 

import java.util.*; 

 

//zhadan类 

class Bomb 

{ 

//定义zhadan的坐标 

int x,y; 

//zhadan的生命 

int life=9; 

//zhadan是否还是活的 

boolean isLive=true; 

public Bomb(int x,int y) 

{ 

this.x=x; 

this.y=y; 

} 

//减少zhadan生命值 

public void lifeDown() 

{ 

if(life>0) 

{ 

life--; 

} 

else 

{ 

this.isLive=false; 

} 

} 

} 

 

//子弹类 

class Shot implements Runnable 

{ 

int x,y,direct; 

int speed=3; 

//是否还活着 

boolean isLive=true; 

 

public Shot(int x,int y,int direct) 

{ 

this.x=x; 

this.y=y; 

this.direct=direct; 

} 

 

@Override 

public void run() { 

//子弹向前跑动 

while(true) 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

switch(direct) 

{ 

case 0: //子弹向右 

x+=speed; 

break; 

case 1: //子弹向左 

x-=speed; 

break; 

case 2: //子弹向下 

y+=speed; 

break; 

case 3: //子弹向上 

y-=speed; 

break; 

} 

//System.out.println("子弹坐标x="+x+" y="+y); 

 

//子弹何时死亡 

//判断该子弹是否碰到边缘 

if(x<0||x>400||y<0||y>300) 

{ 

this.isLive=false; 

break; 

} 

} 

} 

} 

 

 

//坦克类 

class Tank 

{ 

//表示坦克的横坐标 

int x=0; 

//坦克纵坐标 

int y=0; 

//坦克方向 

int direct=0;//0表示右，1表示左，2表示下，3表示上 

//坦克的速度 

int speed=1; 

//坦克的颜色 

int color; 

 

boolean isLive=true; 

 

public int getColor() { 

return color; 

} 

 

public void setColor(int color) { 

this.color = color; 

} 

 

public int getSpeed() { 

return speed; 

} 

 

public void setSpeed(int speed) { 

this.speed = speed; 

} 

 

public int getDirect() { 

return direct; 

} 

 

public void setDirect(int direct) { 

this.direct = direct; 

} 

 

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 Tank(int x,int y) 

{ 

this.x=x; 

this.y=y; 

} 

 

} 

 

//敌人的坦克,把敌人坦克做成线程类 

class EnemyTank extends Tank implements Runnable 

{ 

//boolean isLive=true;//是否死亡 

int times=0; 

 

//定义一个向量，可以存放敌人的子弹 

Vector<Shot>ss=new Vector<Shot>(); 

 

//敌人添加子弹，应当在刚刚创建坦克和敌人的坦克子弹是死亡之后 

 

public EnemyTank(int x,int y) 

{ 

super(x,y); 

} 

 

@Override 

public void run() { 

//让敌人坦克坐标不停的变化 

while(true) 

{ 

switch(this.direct) 

{ 

case 0: //说明坦克正在向右移动 

for(int i=0;i<30;i++) 

{ 

if(x<400)//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

x+=speed; 

} 

} 

break; 

case 1: //说明坦克正在向左移动 

for(int i=0;i<30;i++) 

{ 

if(x>0)//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

x-=speed; 

} 

} 

break; 

case 2: //说明坦克正在向下移动 

for(int i=0;i<30;i++) 

{ 

if(y<280)//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

y+=speed; 

} 

} 

break; 

case 3: //说明坦克正在向上移动 

for(int i=0;i<30;i++) 

{ 

if(y>0)//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

y-=speed; 

} 

} 

break; 

} 

 

this.times++; 

 

if(times%2==0)//3秒时间到了 

{ 

if(isLive) 

{ 

if(ss.size()<5) 

{ 

Shot s=null; 

//添加子弹 

switch(direct) 

{ 

case 0: //坦克朝右 

//创建一颗子弹 

s=new Shot(x+30,y+9,0); 

//把子弹加入集合向量 

ss.add(s); 

break; 

case 1: //坦克朝左 

s=new Shot(x,y+9,1); 

//把子弹加入向量 

ss.add(s); 

break; 

case 2: //坦克朝下 

s=new Shot(x+9,y+30,2); 

//把子弹加入向量 

ss.add(s); 

break; 

case 3: //坦克朝上 

s=new Shot(x+9,y,3); 

//把子弹加入向量 

ss.add(s); 

break; 

} 

 

//启动子弹线程 

Thread t=new Thread(s); 

t.start(); 

} 

} 

} 

 

//让坦克随机产生一个新的方向 

this.direct=(int)(Math.random()*4); 

 

//判断敌人坦克是否死亡 

if(this.isLive==false) 

{ 

//让坦克死亡后退出线程 

break; 

} 

} 

} 

} 

 

//我的坦克 

class Hero extends Tank 

{ 

//子弹 

Shot s=null; 

//定义一个用于存放子弹的集合 

Vector<Shot> ss=new Vector<Shot>(); 

 

public Hero(int x,int y) 

{ 

super(x,y);//用父类的构造函数初始化子类的成员变量 

} 

 

//发射子弹 

public void shotEnemy() 

{ 

switch(this.direct) 

{ 

case 0: //坦克朝右 

//创建一颗子弹 

s=new Shot(x+30,y+9,0); 

//把子弹加入集合向量 

ss.add(s); 

break; 

case 1: //坦克朝左 

s=new Shot(x,y+9,1); 

//把子弹加入向量 

ss.add(s); 

break; 

case 2: //坦克朝下 

s=new Shot(x+9,y+30,2); 

//把子弹加入向量 

ss.add(s); 

break; 

case 3: //坦克朝上 

s=new Shot(x+9,y,3); 

//把子弹加入向量 

ss.add(s); 

break; 

} 

//启动子弹线程 

Thread t=new Thread(s); //因为子弹类Shot实现了Runnable接口 

t.start(); 

} 

 

//坦克向上移动 

public void moveUp() 

{ 

y-=speed; 

} 

//坦克向右移动 

public void moveRight() 

{ 

x+=speed; 

} 

//坦克向下移动 

public void moveDown() 

{ 

y+=speed; 

} 

//坦克向左移动 

public void moveLeft() 

{ 

x-=speed; 

} 

}
分享到：
| Java笔记5(java绘图原理、事件处理机制、监 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java坦克大战+各开发过程版本+笔记

    本篇将详细介绍Java坦克大战的开发过程、关键技术和学习笔记。 首先，我们要理解Java坦克大战的基本架构。游戏通常由以下几个核心部分组成：游戏主循环、图形渲染、用户输入处理、物理引擎和游戏逻辑。在Java坦克...

    Java多线程笔记

    Java多线程笔记是 Java 编程语言中关于多线程编程的笔记，涵盖了线程基础知识、线程优先级、线程状态、守护线程、构造线程、线程中断等多方面的内容。 获取简单 main 程序中的线程 在 Java 中，可以使用 ...

    java学习笔记2（多线程）

    java学习笔记2（多线程）java学习笔记2（多线程）

    java多线程笔记

    Java线程的知识点总结。doc

    JAVA 多线程学习笔记

    这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...

    Java并发编程学习笔记 pdf 多线程编程

    Java并发编程学习笔记，...目前，在JAVA并发编程方面的论述系统且内容详实的技术资料不太多，Java并发编程学习笔记是作者在实际工作中的经验总结，一般来说，当你读完了前8章，你已经足以可以应对JAVA的多线程编程了。

    马士兵多线程笔记.zip

    6. **线程优先级**：操作系统为线程分配了优先级，高优先级线程可能会优先获得CPU执行时间，但并非绝对。线程优先级的设置应谨慎，以免影响系统的稳定性和公平性。 7. **线程池**：Java的Executor框架引入了线程池...

    Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习

    在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者逐步掌握这一关键...

    java多线程笔记全手打

    本笔记全面涵盖了多线程的学习，包括基础理论和实践代码，旨在帮助开发者深入理解并掌握Java多线程技术。 一、线程基础知识 线程是操作系统分配CPU时间的基本单位，一个进程中可以包含多个线程。Java通过`Thread`类...

    张孝祥Java多线程与并发库高级应用笔记

    ### 张孝祥Java多线程与并发库高级应用笔记概览 #### 一、Java多线程技术的重要性与挑战 Java线程技术是软件工程领域不可或缺的一部分，尤其在底层编程、Android应用开发以及游戏开发中，其重要性不言而喻。然而，...

    java学习笔记5（java多线程）

    java学习笔记5（java多线程）java学习笔记5（java多线程）

    基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip

    基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码....

    Java分布式应用学习笔记05多线程下的并发同步器

    ### Java分布式应用学习笔记05多线程下的并发同步器 #### 1. 前言 在现代软件开发中，特别是在分布式系统和高性能计算领域，有效地管理多线程之间的协同工作至关重要。Java语言提供了丰富的工具和API来帮助开发者...

    java基础：多线程学习笔记

    java基础：多线程学习笔记

    多线程学习笔记

    多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...

    java笔记.zip

    2020-4-6 java笔记 --多线程 2020-4-8 java笔记 String类 2020-4-9 java 比较器 2020-4-10 java笔记 枚举类 2020-4-10 java 注解（Annotation） 2020-4-11 Java 集合 2020-4-15 java 泛型 2020-4-18 java IO流 2020-...

    java学习笔记_多线程.txt

    java学习笔记_多线程.txt，包括死锁的原因和解锁的方法。

    韩顺平循序渐进学java从入门到精通课件-笔记坦克大战全过程

    根据提供的文件内容，我们可以从中提炼出与Java编程和游戏开发相关的一系列知识点。以下是对该文件内容的详细解析： Java基础知识点： 1. Java类和对象的创建：文件中定义了多个类，如`Tanker1.0`、`MyPanel`、`...

    多线程笔记_java/多线程_

    在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。本文档将全面解析多线程的基础知识，从简单到复杂，帮助开发者深入理解并掌握这一核心技术。 一、多线程基础 1.1 线程...

Magicbox
Global site tag (gtag.js) - Google Analytics