飞机大战分析及代码

射击游戏分析：
射击游戏需求:
1.所参与的角色:英雄机、子弹、小敌机、大敌机、小蜜蜂、天空
2.角色间的关系:
1)英雄机发射子弹(单倍火力、双倍火力)
2)子弹打敌人(小敌机、大敌机、小蜜蜂)，若打上了:
2.1)子弹消失、敌人先爆破再消失
2.2)若打的是小敌机，则玩家得1分
若打的是大敌机，则玩家得3分
若打的是小蜜蜂，则英雄机得奖励(1条命或40火力值)
3)敌人(小敌机、大敌机、小蜜蜂)撞英雄机，若撞上了:
3.1)敌人先爆破再消失
3.2)英雄机减1条命，同时，清空火力值
当英雄机命数为0时，则游戏结束
4)英雄机、子弹、小敌机、大敌机、小蜜蜂在天空上飞

1.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试
2.设计FlyingObject超类，6个对象类继承超类
3.给FlyingObject设计两个构造方法，6个对象类分别调用

1.将小敌机数组、大敌机数组、小蜜蜂数组组合为FlyingObject数组，并测试
2.在6个对象类中重写step()移动
3.画窗口:----在World类中
1)import JFrame+JPanel
2)设计World类继承JPanel
3)将main中的代码Ctrl C+V
4)main中: frame.setSize()的参数修改为400,700

1.给类中成员添加访问控制修饰符
2.设计Images图片工具类

1.设计窗口的宽和高为常量，适当地方做修改
2.画对象:
1)想画对象需要获取对象的图片，每个对象都能获取图片，
意味着获取图片行为为共有行为，所以设计在超类FlyingObject中，
每个对象获取图片的行为都是不一样的，所以设计抽象方法
----在FlyingObject中设计抽象方法getImage()获取对象的图片
2)获取图片时需要考虑对象的状态，那是因为在不同状态下获取的图片是不同的，
因为每个对象都有状态，意味着状态为共有属性，所以设计在超类FlyingObject中
状态一般都设计为常量，同时再设计变量state来表示当前状态
----在FlyingObject中设计LIVE、DEAD、REMOVE常量，state变量
获取图片时需在去判断对象的状态，每个对象都得状态判断，
意味着判断状态为共有行为，所以设计在超类FlyingObject中，
每个对象判断状态的行为都是一样的，所以设计为普通方法
----在FlyingObject中设计isLive()、isDead()、isRemove()判断状态
3)重写getImage()获取对象的图片:
3.1)天空Sky，直接返回sky图片即可
3.2)英雄机Hero，直接返回heros[0]和heros[1]来回切换
3.3)子弹Bullet:
3.3.1)若活着的，直接返回bullet图片即可
3.3.2)若死了的，直接删除(不返回图片)
3.4)小敌机Airplane:
3.4.1)若活着的，直接返回airs[0]图片即可
3.4.2)若死了的，依次返回airs[1]到airs[4]图片，4后删除(不返回图片)
3.5)大敌机BigAirplane:
3.5.1)若活着的，直接返回bairs[0]图片即可
3.5.2)若死了的，依次返回bairs[1]到bairs[4]图片，4后删除(不返回图片)
3.6)小蜜蜂Bee:
3.6.1)若活着的，直接返回bees[0]图片即可
3.6.2)若死了的，依次返回bees[1]到bees[4]图片，4后删除(不返回图片)
4)图片有了，则可以开画了
----在World类中重写paint()方法

if(isLive()){ 活着呢 }else{ 死了的+删除的 }

分支结构使用几路结构:
----不是看要干几件事，而是看有几种情况
若不考虑爆破，状态有两种:
1)活着的
2)删除的
若考虑爆破，状态有三种:
1)活着的
2)死了的(半死不活，需爆破)
3)删除的

1.敌人入场:
1)敌人是由窗口产生的，所以在World类中设计nextOne()生成敌人对象
2)敌人入场为定时发生的，所以在run()中调用enterAction()实现敌人入场
在enterAction()中:
每400毫秒，获取敌人对象obj，enemies扩容，将obj装到enemies最后一个元素上
注意:在run()中调用enterAction()后，还得再调用repaint()方法来重画
2.子弹入场:
1)子弹是由英雄机发射出来的，所以在Hero类中设计shoot()生成子弹对象
2)子弹入场为定时发生的，所以在run()中调用shootAction()实现子弹入场
在shootAction()中:
每300毫秒，获取子弹数组对象bs，bullets扩容，将bs追加到bullets的末尾

1.飞行物移动:
1)飞行物移动为对象共有的行为，所以在FlyingObject中设计抽象方法step()，派生类中重写
2)飞行物移动为定时发生的，所以在run()中调用stepAction()实现飞行物移动
在stepAction()中:
天空动，遍历敌人敌人动，遍历子弹子弹动
2.英雄机随着鼠标移动:
1)英雄机随着鼠标动为英雄机的行为，所以在Hero中设计moveTo()实现英雄机随着鼠标移动
2)英雄机随着鼠标移动为事件触发的，所以在侦听器中重写mouseMoved()鼠标移动事件
在mouseMoved()中:
获取鼠标的x坐标和y坐标，调用moveTo()方法
3.删除越界的敌人和子弹:
1)在FlyingObject中设计isOutOfBounds()判断敌人是否越界
在Bullet中重写isOutOfBounds()判断子弹是否越界
2)删除越界敌人和子弹为定时发生的，所以在run()中调用outOfBoundsAction()删除越界的敌人和子弹
在outOfBoundsAction()中:
遍历所有敌人，判断若越界了，则最后一个敌人替换越界的敌人，缩容
遍历所有子弹，判断若越界了，则最后一个子弹替换越界的子弹，缩容
4.设计EnemyScore得分接口，小敌机和大敌机实现EnemyScore
设计EnemyAward奖励接口，小蜜蜂实现EnemyAward

1.子弹与敌人的碰撞:
1)在FlyingObject中设计isHit()检测碰撞、goDead()飞行物去死
在Hero中设计addLife()增命、addFire()增火力
2)子弹与敌人的碰撞为定时发生的，所以在run()中调用bulletBangAction()实现子弹与敌人的碰撞
在bulletBangAction()中:
遍历子弹得子弹，遍历敌人得敌人，判断若都活着并且还撞上了:
子弹去死、敌人去死
判断若为EnemyScore，则将被撞对象强转为EnemyScore，玩家得分
判断若为EnemyAward，则将被撞对象强转为EnemyAward，获取奖励类型，得奖励
2.画分和画命:
1)在Hero中设计getLife()获取英雄机的命数
2)在World类的paint()中: 画分和画命
3.英雄机与敌人的碰撞:
1)借用FlyingObject中的isHit()检测碰撞、goDead()飞行物去死
在Hero中设计subtractLife()减命、clearFire()清空火力值
2)英雄机与敌人的碰撞为定时发生的，所以在run()中调用heroBangAction()实现英雄机与敌人的碰撞
在heroBangAction()中:
遍历所有敌人得敌人，判断若都活着并且还撞上了:
敌人去死、英雄机减命、英雄机清空火力值

1.检测游戏结束:
1)借用Hero的getLife()获取英雄机的命数
2)检测游戏结束为定时发生的，所以在run()中设计checkGameOverAction()实现检测游戏结束
在checkGameOverAction()中:
判断若英雄机的命数<=0，表示游戏结束了，则…
2.画状态:
1)在World类中设计START、RUNNING、PAUSE、GAME_OVER常量，同时设计state变量表示当前状态
在Images类中设计start,pause,gameover状态图片，并赋值
在World类的paint()中: 设计在不同的状态下画不同的图片
2)设计那一堆action，为仅在运行状态下执行
设计英雄机随着鼠标移动，为仅在运行状态下执行
3)重写mouseClicked()鼠标点击事件:
启动变运行，游戏结束先清理现场再变启动
重写mouseExited()鼠标移出事件:
运行变暂停
重写mouseEntered()鼠标移入事件:
暂停变运行

小敌机：Airplane

  package cn.tedu.shoot;
  import java.awt.image.BufferedImage;
  public class Airplane extends FlyingObject implements EnemyScore{
  private int speed;   //移动速度	
	public Airplane(){  //构造方法
		super(48,50);   //小敌机的宽高
		speed = 2;      //移动速度
	}
	/*重写step()移动*/
	public void step() {
		y+=speed;  //y+向下
	}
	
	private int index = 1;  //爆破图的下标
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {  //每十毫秒走一次
		if(isLive()) {
			return Images.airs[0]; 
		}else if(isDead()) {
			BufferedImage img = Images.airs[index++];  //获取爆破图
			if(index==Images.airs.length) {  //到最后一张了
				state = REMOVE;   //将当前状态修改为REMOVE删除状态
			}
			return img;  //返回爆破图
		}
		return null;  //删除状态不返回图片
		
		/*
		 *                    index=1
		 * 10M  img=airs[1]   index=2   airs[1]
		 * 20M  img=airs[2]   index=3   airs[2]
		 * 30M  img=airs[3]   index=4   airs[3]
		 * 40M  img=airs[4]   index=5   airs[4]
		 *                    (REMOVE)
		 * 50M  不返回图片                   
		 */
	}
	
	public int getScore() {
		return 1; //打掉小敌机玩家得1 分
	}
}

大敌机：BigAirplane

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
public class BigAirplane extends FlyingObject implements EnemyScore{
	private int speed;
	public BigAirplane(){
		super(66,89);
		speed = 2;
	}
	public void step() {
		y+=speed;  //y+向下
	}
	
	private int index = 1;  //爆破图的下标
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {  //每十毫秒走一次
		if(isLive()) {
			return Images.bairs[0];  
		}else if(isDead()) {
			BufferedImage img = Images.bairs[index++];  //获取爆破图
			if(index==Images.bairs.length) {  //到最后一张了
				state = REMOVE;   //将当前状态修改为REMOVE删除状态
			}
			return img;  //返回爆破图
		}
		return null;  //删除状态不返回图片
	}
	
	/*重写getScore()*/
	public int getScore() {
		return 3;  //打掉大敌机,玩家得3分
	}
}

小蜜蜂：Bee

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
import java.util.Random;

public class Bee extends FlyingObject implements EnemyAward{
	private int xSpeed;
	private int ySpeed;
    private int awardType;
    
    public Bee(){
    	super(60,51);
		Random rand = new Random();
		xSpeed = 1;
		ySpeed = 2;
		awardType = rand.nextInt(2);   //0到1之间
		
    }
    public void step() {
    	x+=xSpeed;  //x向左向右
    	y+=ySpeed;  //y+向下
    	if(x<=0 || x>=World.WIDTH-width){          //若x<=0或X>=(窗口宽-蜜蜂宽),表示到头了
			xSpeed*=-1;  //切换方向(正便=变负、负变正)
		}
	}
    
    private int index = 1;  //爆破图的下标
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {  //每十毫秒走一次
		if(isLive()) {
			return Images.bees[0]; 
		}else if(isDead()) {
			BufferedImage img = Images.bees[index++];  //获取爆破图
			if(index==Images.bees.length) {  //到最后一张了
				state = REMOVE;   //将当前状态修改为REMOVE删除状态
			}
			return img;  //返回爆破图
		}
		return null;  //删除状态不返回图片
	}
	
	public int getAwardType() {
		return awardType;  //返回奖励类型
	}
}

英雄机：Hero

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
public class Hero extends FlyingObject{
	private int life;
	private int fire;
		
	public Hero(){
		super(97,139,140,400);
		life = 3;
		fire = 0;
	}
	
	public void step() {
	}
	
	int index = 0;  //下标
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {   //每十个毫毛走一次
		return Images.heros[index++%Images.heros.length];  //在0到1之间来回切换
		
		/*                   index=0;
		  10M   返 回hero[0]   index=1;
		  20M   返 回hero[1]   index=2;
		  30M   返 回hero[0]   index=3;
		  40M   返 回hero[1]   index=4;
		 */
	}
	
	/*英雄机发射子弹(生成子弹对象)*/
	public Bullet[] shoot() {   
		int xStep = this.width/4;   //1/4英雄机的宽
		int yStep = 2;
		if(fire>0) {   //双倍火力
			Bullet[] bs = new Bullet[2];  //2发子弹
			bs[0] = new Bullet(this.x+1*xStep,this.y-yStep);  //x:英雄机的x+1/4英雄机的宽  y:英雄机的y-固定的20
			bs[1] = new Bullet(this.x+3*xStep,this.y-yStep);  //x:英雄机的x+3/4英雄机的宽  y:英雄机的y-固定的20
			fire-=2;    //发射一次双倍火力,则火力值减2
			return bs;
		}else {   //单倍
			Bullet[] bs = new Bullet[1];  //1发子弹
			bs[0] = new Bullet(this.x+2*xStep,this.y-yStep);  //x:英雄机的x+2/4英雄机的宽  y:英雄机的y-固定的20
			return bs;
		}
	}
	
	/*英雄机随着鼠标移动*/
	public void moveTo(int x,int y) {
		this.x = x-this.width/2;   //英雄机的x=鼠标的x-1/2英雄机的宽
		this.y = y-this.height/2;  //英雄机的y=鼠标的y-1/2英雄机的高
	}
	
	/*英雄机增命*/
	public void addLife() {
		life++;  //命数加1
	}
	
	/*获取英雄机的命*/
	public int getLife() {
		return life;    //返回命数
	}
	/*英雄机减命*/
	public void subtractLife() {
		life--;  
	}
	
	/*清空火力值*/
	public void clearFire() {
		fire=0;  //火力值为零
	}
	
	/*英雄机增火力*/
	public void addFire() {
		fire+=40;   //火力值增40
	}
}

天空：Sky

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
public class Sky extends FlyingObject{
	private int speed;
	private int y1;   //第二张图的y坐标
	
	/*构造方法*/
	public Sky(){
		super(World.WIDTH,World.HEIGHT,0,0);
		speed = 1;
		y1 = -World.HEIGHT;
	}
	public void step() {
		y += speed;   //y+(向下)
		y1+= speed;   //y+(向下)
		if(y>=World.HEIGHT) {  //若y>=窗口的高,意味着y移出去了
			y=-World.HEIGHT;   //则修改y的值为负的窗口的高（挪到最上面去了）
		}
		if(y1>World.HEIGHT) {  //若y1>=窗口的高,意味着y1一出去了
			y1=-World.HEIGHT;  //则修改y1的值为负的窗口的高（挪到最上面去了）
		}
	}
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {
		return Images.sky;  //直接返回sky图片即可
	}
	
	public int getY1() {
		return y1;
	}
}

子弹：Bullet

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
public class Bullet extends FlyingObject{
	private int speed;
	
	public Bullet(int x,int y){   //子弹有许多个,每个子弹的初始坐标都不同
		super(8,20,x,y);
		speed = 3;
	}
	public void step() {
		y-=speed;  //y+向上
	}
	
	/*重写getImage()获取图片*/
	public BufferedImage getImage() {   
		if(isLive()) {
			return Images.bullet;    //直接返回图片
		}else if(isDead()){     //若死了的
			state = REMOVE;    //将状态修改为REMOVE删除状态
		}
		return null;  //死了的和删除的,都不反图片
		/*
		//若活着的,返回bullet 图片
		//若死了的,状态改为删除,同时不返回图片
		//若删除的不返回图片
		*/
	}
	
	/*重写isOutOfBounds()判断子弹是否越界*/
	public boolean isOutOfBounds() {
		return y<=-height;  //敌人的y>=窗口的高,即为越界了
	}
}

超类：FlyingObject

package cn.tedu.shoot;
import java.util.Random;
import java.awt.image.BufferedImage;
/*飞行物*/
public abstract class FlyingObject {
	public static final int LIVE = 0;   //活着的
	public static final int DEAD = 1;   //死了的
	public static final int REMOVE = 2; //删除的
	protected int state = LIVE;   //当前状态默认为活着的
	
	protected int width;   //宽
	protected int height;  //高
	protected int x;       //x坐标
	protected int y;       //y坐标
	
	//专门给小敌机,大敌机,小蜜蜂提供的
	//因为三种敌人的宽高不同,所以数据得写活,自然传参
	//因为三种敌人的x和y坐标相同,所以直接写死,不需要传参
	public FlyingObject(int width,int height){
		this.width=width;
		this.height=height;
		Random rand = new Random();   //随机数对象
		x = rand.nextInt(World.WIDTH-width);  //0到（窗口宽-小敌机宽）之间是随机数
		y = -height;                  //y:负的敌人的高
	}
	
	/*专门给英雄机、天空、子弹提供的*/
	//因为英雄机,天空,子弹的宽高xy都不同,所以数据都得写活,都得传参过来
	public FlyingObject(int width,int height,int x,int y){
		this.width=width;
		this.height=height;
		this.x=x;
		this.y=y;
		
	}	
	public abstract void step();
	/*获取对象的图片*/
	public abstract BufferedImage getImage();
	/*判断是否活着的*/
	public boolean isLive() {
		return state==LIVE;  //当前状态为LIVE则表示为活着的,返回true,否则返回flase
	}
	   /*判断是死了着的*/
	public boolean isDead() { //当前状态为DEAD则表示为活着的,返回true,否则返回flase
		return state==DEAD;
	}
	  /*判断是否删除的*/ 
	public boolean isRemove() { //当前状态为REMOVE则表示为活着的,返回true,否则返回flase
		return state==REMOVE;
	}
	
	/*判断敌人是否越界*/
	public boolean isOutOfBounds() {
		return y>=World.HEIGHT;  //敌人的y>=窗口的高,即为越界了
	}
	
	/*检测敌人与子弹/英雄机的碰撞  this:敌人  other:子弹/英雄机*/
	public boolean isHit(FlyingObject other) {
		int x1 = this.x-other.width;  //x1:敌人的x-子弹/英雄机的宽
		int x2 = this.x+this.width;   //x2:敌人的x+敌人的宽
		int y1 = this.y-other.height; //y1:敌人的y-子弹/英雄机的高
		int y2 = this.y+this.height;  //y2:敌人的y+敌人的高
		int x = other.x;    //x:子弹/英雄机的x
		int y = other.y;    //y:子弹/英雄机的y
		
		return x>=x1 && x<=x2 && y>=y1 && y<=y2;
	}
	
	/*飞行物去死*/
	public void goDead() {
		state = DEAD;  //将当前状态修改为DEAD死了的
	}
}

图片工具类：Images

package cn.tedu.shoot;
//图片工具类
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
public class Images {
//  公开的 静态的   数据类型   变量名
	public static BufferedImage sky;
	public static BufferedImage bullet;
	public static BufferedImage[] heros;
	public static BufferedImage[] airs;
	public static BufferedImage[] bairs;
	public static BufferedImage[] bees;
	
	public static BufferedImage start;
	public static BufferedImage pause;
	public static BufferedImage gameover;
	
	static {
		start = readImage("start.png");
		pause = readImage("pause.png");
		gameover = readImage("gameover.png");
		
		sky = readImage("background.png");
		bullet = readImage("bullet.png");
		
		heros = new BufferedImage[2];
		heros[0] = readImage("hero0.png");
		heros[1] = readImage("hero1.png");
		
		airs = new BufferedImage[5];
		airs[0] = readImage("airplane.png");
		bairs = new BufferedImage[5];
		bairs[0] = readImage("bigairplane.png");
		bees = new BufferedImage[5];
		bees[0] =  readImage("bee.png");		
		for(int i=1;i<airs.length;i++) {  //赋值爆破图
			airs[i] = readImage("bom"+i+".png");
			bairs[i] = readImage("bom"+i+".png");
			bees[i] = readImage("bom"+i+".png");
		}
	}
	public static BufferedImage readImage(String fileName){
		try{
			BufferedImage img = ImageIO.read(FlyingObject.class.getResource(fileName));
			return img;
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException();
		}
	}
}

得分奖励接口：EnemyScore

package cn.tedu.shoot;
/*得分接口*/
public interface EnemyScore {
	public int getScore();  //得分
}

得命或火力值奖励接口：EnemyAward

package cn.tedu.shoot;
/*奖励接口*/
public interface EnemyAward {
	public int FIRE = 0;  //火力
	public int LIFE = 1;  //命
	
	/*获取奖励类型*/
	public int getAwardType();
}

测试类：World

package cn.tedu.shoot;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Random;
import java.util.Arrays;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
public class World extends JPanel {
	public static final int WIDTH = 400; // 窗口的宽
	public static final int HEIGHT = 700; // 窗口的高
	
	public static final int START = 0;   //启动状态
	public static final int RUNNING = 1; //运行状态
	public static final int PAUSE = 2;   //暂停状态
	public static final int GAME_OVER = 3;  //游戏结束状态
	private  int state = START;   //当前状态(默认为启动状态)
	
	private Sky sky = new Sky(); // 天空对象
	private Hero hero = new Hero(); // 英雄机

	private FlyingObject[] enemies = {}; // 敌人组
	private Bullet[] bullets = {}; // 子弹数组

	/* 敌人生成(小敌机,大敌机,小蜜蜂)对象 */
	public FlyingObject nextOne() {
		Random rand = new Random();
		int type = rand.nextInt(20); // 0到19之间的随机数
		if (type < 5) { // 0到4返回小蜜蜂对象
			return new Bee();
		} else if (type < 13) { // 5到12返回小蜜蜂对象
			return new Airplane();
		} else { // 13到19返回大敌机对象
			return new BigAirplane();
		}
	}

	private int enterIndex = 0;
	/* 敌人(小敌机,大敌机,小蜜蜂)入场 */	
    public void enterAction() { // 每10毫秒做一次
		enterIndex++; // 每10毫秒增1
		if (enterIndex % 40 == 0) { // 每400毫秒走一次
			FlyingObject obj = nextOne(); // 获取敌人对象
			enemies = Arrays.copyOf(enemies, enemies.length + 1); // 扩容
			enemies[enemies.length - 1] = obj; // 将obj添加到最后一个元素上
		}
	}

	private int shootIndex = 0; // 子弹入场计数
	/* 子弹入场 */
	public void shootAction() { // 每10毫秒走一次
		shootIndex++; // 每10毫秒走一次
		if (shootIndex % 30 == 0) { // 每300毫秒走一次
			Bullet[] bs = hero.shoot(); // 获取子弹数组对象
			bullets = Arrays.copyOf(bullets, bullets.length + bs.length); // 扩容(bs有几个元素就扩大几个元素)
			System.arraycopy(bs, 0, bullets, bullets.length - bs.length, bs.length); // 数组的追加
		}
	}

	/*飞行物移动*/
	public void stepAction() {
		sky.step();  //天空动
		for(int i=0;i<enemies.length;i++) {  //遍历所有敌人
			enemies[i].step();   //敌人动
		}
		for(int i=0;i<bullets.length;i++) {   //遍历所有子弹
			bullets[i].step();   //子弹动
		}
	}
	
	/*删除越界的敌人和子弹*/
	public void outOfBoundsAction() {    //每10毫秒走一次
		for(int i=0;i<enemies.length;i++) {  //遍历所有敌人
			if(enemies[i].isOutOfBounds() || enemies[i].isRemove()) { //判断是否出界或爆破
				enemies[i] = enemies[enemies.length-1];  //把最后一个敌人放在出界敌人的位置
				enemies = Arrays.copyOf(enemies,enemies.length-1);  //缩容
			}
		}
		for(int i=0;i<bullets.length;i++) {   //遍历所有子弹
			if(bullets[i].isOutOfBounds() || bullets[i].isRemove()) {  //判断是否出界或爆破
				bullets[i] = bullets[bullets.length-1];   //把最后一个子弹放在出界子弹的位置
				bullets = Arrays.copyOf(bullets,bullets.length-1);  //缩容
			}
		}
	}
	
	private int score = 0;   //玩家得分
	/*子弹与敌人的碰撞*/
	public void bulletBangAction() {
		for(int i=0;i<bullets.length;i++) {  //遍历所有子弹
			Bullet b = bullets[i];   //获取每个子弹
			for(int j=0;j<enemies.length;j++) {   //遍历所有敌人
				FlyingObject f = enemies[j];    //获取每个敌人
				if(b.isLive() && f.isLive() && f.isHit(b)) {  //若都活着并且还撞上了 
					b.goDead();   //子弹去死
					f.goDead();   //敌人去死
					
					if(f instanceof EnemyScore) {  //若被撞敌人为分
						EnemyScore es = (EnemyScore)f;  //将被撞敌人强转为得分接口
						score += es.getScore();   //玩家得分
					}
					if(f instanceof EnemyAward) {  //若被撞敌人为奖励
						EnemyAward ea = (EnemyAward)f;   //将被撞敌人强转为奖励接口
						int type = ea.getAwardType();    //获取奖励类型
						switch(type) {    //根据奖励类型来获取不同的奖励
						case EnemyAward.FIRE:  //若奖励类型为火力
							hero.addFire();    //则英雄机增火力
							break;
						case EnemyAward.LIFE:  //若奖励类型为名
							hero.addLife();    //则英雄机增命
							break;
						}
					}
				}
			}
		}
	}
	
	/*英雄机与敌人撞*/
	public void heroBangAction() {  //每10毫秒走一次
		for(int i=0;i<enemies.length;i++) {  //遍历所有敌人
			FlyingObject f = enemies[i];  //获取每个敌人
			if(hero.isLive() && f.isLive() && f.isHit(hero)) {
				f.goDead();  //敌人去死
				hero.subtractLife();  //英雄机减命
				hero.clearFire();   //英雄机清空火力
			}
		}
	}
	
	public void checkGameOverAction() {
		if(hero.getLife()<=0) {   //表示游戏结束了
			state = GAME_OVER;  //将当前状态修改为游戏结束状态
		}
	}
	
	/* 启动程序的执行 */
	public void action() {
		MouseAdapter m = new MouseAdapter() {
			public void mouseMoved(MouseEvent e) {
				if(state==RUNNING) {
					int x = e.getX();  //获取鼠标的x坐标
					int y = e.getY();  //获取鼠标的y坐标
					hero.moveTo(x,y);  //英雄机随着鼠标移动
				}			
			}
			
			public void mouseClicked(MouseEvent e) {
				switch(state) {   //根据当前状态做不同的处理
				case START:   //启动状态时修改为运行状态
					state = RUNNING;
					break;
				case GAME_OVER:  //游戏结束状态时修改为启动状态
					score = 0;  //先清理现场,在修改为启动状态
					sky = new Sky();
					hero = new Hero();
					enemies = new FlyingObject[0];
					bullets = new Bullet[0];
					state = START;
					break;
				}
			}
			/*重写mouseExited()鼠标移出事件*/
			public void mouseExited(MouseEvent e) {
				if(state==RUNNING) {  //运行状态时修改为暂停状态
					state = PAUSE;
				}
			}
			/* 重写mouseEntered()鼠标移入事件*/
			public void mouseEntered(MouseEvent e) {
				if(state==PAUSE) {   //暂停状态时修改为运行状态
					state = RUNNING;
				}
			}
		};
		this.addMouseListener(m);
		this.addMouseMotionListener(m);
		
		Timer timer = new Timer(); // 定时器对象
		int intervel = 10; // 定时间隔(以毫秒为单位)
		timer.schedule(new TimerTask() {
			public void run() { // 定时器干的事(每十毫秒走一次)
				// 敌人入场 子弹入场 飞行物移动 子弹与敌人碰撞 英雄机与敌人碰撞
				if(state==RUNNING) {   //仅在运行状态下执行
					enterAction();  //敌人(小敌机,大敌机,小蜜蜂)入场
					shootAction();  //子弹入场
					stepAction();   //飞行物移动
					outOfBoundsAction();  //删除越界敌人
					bulletBangAction();   //子弹与敌人碰撞
					heroBangAction();   //英雄机与敌人的碰撞
					checkGameOverAction();  //检测游戏结束
				}				
				repaint(); // 重画 调用repaint() 画笔
			}
		}, intervel, intervel);  //定时计划表
	}
                                 	
	/* 重写paint()画 */
	public void paint(Graphics g) { // 每10毫秒走一次
		g.drawImage(sky.getImage(), sky.x, sky.y, null); // 画天空1
		g.drawImage(sky.getImage(), sky.x, sky.getY1(), null); // 画天空2
		g.drawImage(hero.getImage(), hero.x, hero.y, null); // 画英雄机
		for (int i = 0; i < enemies.length; i++) { // 遍历所有敌人
			FlyingObject f = enemies[i]; // 获取每个敌人
			g.drawImage(f.getImage(), f.x, f.y, null); // 画敌人
		}
		for (int i = 0; i < bullets.length; i++) { // 遍历所有子弹
			Bullet b = bullets[i]; // 获取每个子弹
			g.drawImage(b.getImage(), b.x, b.y, null); // 画子弹
		}
		
		g.drawString("SCORE:"+score,10,25);      //画分
		g.drawString("LIVE:"+hero.getLife(),10,45);   //画命
		
		/*画启动图，暂停图，结束图*/
		switch(state) {
		case START:
			g.drawImage(Images.start,0,0,null);
			break;
		case PAUSE:
			g.drawImage(Images.pause,0,0,null);
			break;
		case GAME_OVER:
			g.drawImage(Images.gameover,0,0,null);
		}
	}

	public static void main(String[] args) {
		JFrame frame = new JFrame();
		World world = new World();
		frame.add(world);

		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(WIDTH, HEIGHT);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); // 设置窗口可见 尽快调用

		world.action();
	}

}