多线程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连接sql2005数据库三步曲
2012-12-27 10:48 686one、two、three 导入java包 import ja ... -
主题：Java面试122题 .
2012-12-27 10:17 8512012-06-05 09:17 592人阅读 ... -
Java六大必须理解的问题
2012-12-27 10:17 4812012-05-24 11:39 793人阅读 评论(6) 收 ... -
多线程知识点整理 .
2012-12-27 10:17 549基本概念 多线程程序 ... -
数据连接池的基本实现 .
2012-12-26 13:20 8251、 实现途径： 编写JdbcPool implemen ... -
java 常用三大集合类
2012-11-23 11:07 13752一、Set集合，其主要实现类有HashSet、TreeSet。 ... -
Java笔记9(Java网络编程)
2012-10-16 14:39 702Java基础9 Java基础9 1 文件结构 ... -
Java笔记8(jdbc-odbc、jdbc、JTable使用、Min版学生管理系统)
2012-10-16 14:34 1406Java基础8 Java基础8 1 文件结构 ... -
swing编程实现闪屏登录效果
2012-09-18 12:07 27061、先写一个闪屏类 package com.mhl.Tools ... -
paint和paintComponent方法的关系
2012-09-18 09:50 911关键词:swing,paint,paintComp ... -
Java笔记7(IO操作、图片拷贝、记事本、测试声音、坦克大战)
2012-08-23 15:05 1017File类的基本用法_Demo12_1.java /* ... -
Java笔记5(java绘图原理、事件处理机制、监听器、坦克大战)
2012-08-23 14:30 2820java绘图原理Demo9_1.java /* ... -
java中equals和==的区别
2012-08-17 10:33 17506ava中equals和==的区别 值类型是存储在内存中的堆栈（ ... -
Java笔记4(布局管理器、常用组件、qq聊天界面、记事本)
2012-08-13 14:12 3371文件结构 布局管理器Demo8_1.java pa ... -
Java笔记3(泛型、异常、成绩评分程序)
2012-08-09 10:31 1018文件结构 泛型与异常 异常 Class7b / c ... -
Java笔记1(java类、接口、封装、继承、多态、约瑟夫环应用)
2012-08-09 10:26 1034文件结构 Java访问修饰符 com.xiaoming ... -
Java笔记2(数组、排序、查找、集合类、移位)
2012-08-09 10:18 1728文件结构 Class5 / com.t ...
相关推荐
一、操作系统中线程和进程的概念 2 二、Java中的线程 3 三、Java中关于线程的名词解释 3 四、线程的状态转换和生命周期 4 Java线程：创建与启动 7 Java线程：线程名称的设定及获取 10 Java线程：线程栈模型与线程的...
java学习笔记2（多线程）java学习笔记2（多线程）
Java坦克大战+各开发过程版本+笔记 是跟着马士兵的那个写的
Java并发编程学习笔记，...目前，在JAVA并发编程方面的论述系统且内容详实的技术资料不太多，Java并发编程学习笔记是作者在实际工作中的经验总结，一般来说，当你读完了前8章，你已经足以可以应对JAVA的多线程编程了。
多线程学习笔记，好资源。包括线程基础等知识多线程学习笔记，好资源。包括线程基础等知识
java笔记java笔记java笔记java笔记java笔记java笔记java笔记
Java入门笔记6_线程
Java分布式应用学习笔记05多线程下的并发同步器
java笔记java笔记,java笔记java笔记java笔记java笔记
java学习笔记java学习笔记java学习笔记java学习笔记
java中的多线程笔记
java学习笔记5（java多线程）java学习笔记5（java多线程）
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码....
完全正确的代码！陆续更新中！(有些不完全是韩老师的代码，加入了自己的一些东西) 坦克大战1.0版 /* * 作者：树的梦想 * 日期：2012.03.04 * 功能：做1.0版坦克大战游戏：画出一辆tanker就行了！ * 过程：
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多线程与并发库高级应用学习笔记，很经典的学习多线程和并发的资料。张孝祥Java多线程讲义笔记由张孝祥亲自整理，很实用的。
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。 一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。 Java中，每个线程都有一个...