JAVA学习之路（八）——飞机大战

任务

第一天

1)建立六个类和world类
2)为他们编写属性和show方法

第二天

1)为六个类添加构造方法
2)构造方法中为属性赋值

第三天

1)在world类中声明需要的类型，包含引用类型数组
2)只需要一个对象的英雄机和天空只实例化一个对象
3)其余对象的创建数组
4)为了减少代码冗余创建一个父类，将所有的类公有属性提取，命名为FlayingObject
5)六个类继承FlyingObject将其中的所有公有属性删除

第四天

FlyingObject
1)编写了两个构造
2)编写了show方法

第五天

1)简化了其他六个子类中的构造代码和show方法中的代码
2)创建一个FlyingObject类型的数组、
3)向数组中存放子类对象（向上造型）
在FlyingObject类中编写了加载图片的方法
每个类在静态块中加载自己的图片
子类所有属性私有化
父类所有属性保护
在world类中创建宽和高的常量，并代替项目中的400,700
将窗体简单框架显示

第六天

1)FlyingObject定义为抽象类
2)将step方法定义为抽象方法
3)定义三个状态常量
4)定义一个状态属性
5)定义一个获得图片方便绘制的方法getImage
6)添加判断状态的方法
7)将图片绘制到窗体上
8)每个子类获得图片的方法

第七天

1)在start方法中编写了计时器
2)编写小敌机、大敌机、小蜜蜂、天空、子弹的step方法
其中，小蜜蜂和天空编写的step代码要格外注意
3)编写stepActiom方法，调用全部（除英雄机）对象的step方法
在计时器方法中调用stepAction方法
4)编写生成敌机方法
5)编写敌人进场的方法，注意每调用40次运行出现一架敌机
在计时器中调用enterAction方法

第八天

1)编写英雄机开炮的方法
2)编写子弹进场的方法
在计时器中调用enterAction方法
3)英雄机类编写shoot方法
3.1)shoot方法返回值子弹类型数组
3.2)根据火力值决定单管双管炮
3.3)如果是双管炮减火力值
3.4)为数组赋值子弹元素，并返回
4)在world类中编写shootAction方法
4.1)调用英雄机的方法并接受返回值
4.2)按照返回值的数组长度对先有的子弹数组扩容
4.3)将返回值的元素复制到子弹数组中
4.4)设计子弹进场的频率为移动25次开炮一次
4.5)计时器中调用shootAction方法
5)在英雄机中编写一个moveTo()方法
6)在world类中添加一个鼠标监听事件，如果鼠标移动，英雄机随之移动

第九天

1)定义一个得分接口
小敌机和大敌机实现该接口
2)定义一个奖励接口
小蜜蜂实现该接口
3)编写敌机和子弹的越界检测
在FlyingObject类中添加越界检测方法，为小敌机、大敌机、小蜜蜂使用
在Bullet类中重写一个越界方法，子弹自己使用
4)在world类中编写outOfBounds方法，判断敌机和子弹是否出界，如果出界将它移除

第十天

1)在FlyingObject中添加一个goDead方法，将当前飞行物状态改为Dead
2)在FlyingObject中添加hit方法，返回值为boolean类型，参数是FlyingObject类型
判断当前对象是否和参数对象发生碰撞，如果碰撞返回true
3)在英雄机中添加：加命方法，加火力方法，获得命方法
4)在world类中编写BulletHitAction方法，功能室检查子弹是否击中了敌机
如果击中了，判断击中目标类型，加分，奖励
5)在wold类中声明了一个score属性作为游戏得分
在paine方法中，在敞口左上角画出当前得分和当前生命值
6)在英雄机类中编写：减命方法清空火力值方法
7)检测英雄机和敌机碰撞
如果英雄机碰撞了敌机，敌机死，英雄机减命且清空火力
8)在检查越界方法中，将敌机和子弹进入新数组的条件中，添加敌机被移除和子弹被移除的判断让死了的子弹和敌机及时从数组中移除
9)在world类中编写了四个窗口状态常量，并定义了当前窗口状态的属性

代码

AirPlane 小敌机

package com.szh;
import java.awt.image.BufferedImage;
import java.util.*;
public class AirPlane extends FlyingObject implements Score{
//小敌机
	private static BufferedImage[] images;
	static{
		images = new BufferedImage[5];
		images[0] = readImage("airplane0.png");
		for(int i=1;i<images.length;i++){
			images[i] = readImage("bom"+i+".png");
		}
	}
	//属性
	private int step;//速度
	//方法
	public AirPlane(){
		super(57,43);
		step = 10;
	}
	public void show(){
		System.out.println("输出小敌机信息:");
		super.show();
		System.out.println("速度:"+step);
	}
	//小敌机移动
	public void step() {
		y+=step;//小敌机向下移动
	}
	//实现Score接口中的方法
	public int getScore() {
		return 1;//击中小敌机得一分
	}
	//小敌机获得各种图片的方法
	int index = 0;
	public BufferedImage getImage() {
		if(isLife()){//若果活着
			return images[0];//获得正常图片
		}
		else if(isDead()){//如果死了
			index++;//计数
			if(index == images.length-1){//如果爆炸完了
				state = REMOVE;//进入离场状态
			}
			return images[index];//获得爆炸图片
		}
		return null;
	}
}

BigAirPlane 大敌机

package com.szh;
import java.awt.image.BufferedImage;
import java.util.*;
public class BigAirPlane extends FlyingObject implements Score{
//大敌机
	private static BufferedImage[] images;
	static{
		images = new BufferedImage[5];
		images[0] = readImage("bigairplane0.png");
		for(int i=1;i<images.length;i++){
			images[i] = readImage("bom"+i+".png");
		}
	}
	//属性
	private int step;//速度
	//方法
	public BigAirPlane(){
		super(69,99);
		step = 8;
	}
	public void show(){
		System.out.println("输出大敌机信息:");
		super.show();
		System.out.println("速度:"+step);
	}
	//大敌机移动
	public void step() {
		y+=step;
	}
	//实现Score接口中的方法
	public int getScore() {
		return 3;//击中大敌机得三分
	}
	//大敌机获得图片的方法
	int index = 0;
	public BufferedImage getImage() {
		if(isLife()){
			return images[0];
		}else if(isDead()){
			index++;
			if(index == images.length-1){
				state = REMOVE;
			}
			return images[index];
		}
		return null;
	}
}

Bee 小蜜蜂

package com.szh;
import java.awt.image.BufferedImage;
import java.util.*;
public class Bee extends FlyingObject implements Award{
//小蜜蜂
	private static BufferedImage[] images;
	static{
		images = new BufferedImage[5];
		images[0] = readImage("bee0.png");
		for(int i=1;i<images.length;i++){
			images[i] = readImage("bom"+i+".png");
		}
	}
	private int xStep;//横向移动速度
	private int yStep;//纵向移动速度
	private int awardType;//奖励类型：0为火力值，1为生命值
	public Bee(){
		super(63,57);
		Random ran = new Random();
		xStep = 10;//横向移动速度
		yStep = 10;//纵向移动速度
		awardType = ran.nextInt(2);//奖励类型随机
	}
	public void show(){
		System.out.println("输出小蜜蜂信息:");
		super.show();
		System.out.println("x轴速度:"+xStep+" y轴速度:"+yStep);
		System.out.println("奖励为:"+(awardType==0?"火力值":"生命值"));
	}
	//小蜜蜂移动
	public void step() {
		y+=yStep;
		x+=xStep;
		//检测是否碰壁
		if(x<=0 || x>=World.WIDTH-width){
			//如果碰壁，xStep更换正负号，切换移动方向
			xStep *= -1;
		}
	}
	//小蜜蜂实现奖励接口
	public int getAwardType() {
		return awardType;//返回奖励类型
	}
	//小蜜蜂获取图片的方法
	int index =0;
	public BufferedImage getImage() {
		if(isLife()){
			return images[0];
		}else if(isDead()){
			index++;
			if(index == images.length-1){
				state = REMOVE;
			}
			return images[index];
		}
		return null;
	}
}

Bullet 子弹

package com.szh;
import java.awt.image.BufferedImage;
public class Bullet extends FlyingObject{
//子弹
	private static BufferedImage image;
	static{
		image = readImage("bullet.png");
	}
	private int step;
	//因为子弹出现的位置是受英雄机影像的，所以x,y作为参数
	public Bullet(int x,int y){
		super(5,11,x,y);
		step = 15;
	}
	public void show(){
		System.out.println("输出子弹信息:");
		super.show();
		System.out.println("速度:"+step);
	}
	//子弹移动
	public void step() {
		y -=step;
	}
	//子弹获得图片的方法
	public BufferedImage getImage() {
		if(isLife()){
			return image;
		}else if(isDead()){
			state = REMOVE;
		}
		return null;
	}
	//重写父类中的越界方法，因为子弹越界是向上的
	public boolean outOfBounds(){
		return this.y<-this.height;
	}
}

Hero 英雄机

package com.szh;
import java.awt.image.BufferedImage;
public class Hero extends FlyingObject{
//英雄机
	private static BufferedImage[] images;
	static{
		images = new BufferedImage[2];
		images[0] = readImage("hero0.png");
		images[1] = readImage("hero1.png");
		/*for(int i=1;i<images.length;i++){
			images[i] = readImage("bom"+i+".png");
		}*/
	}
	private int step;
	private int life;//英雄机生命值
	private int doubleFire;//火力值
	public Hero(){
		super(102,126,(World.WIDTH-97)/2,450);
		life = 3;
		doubleFire = 30;
	}
	public void show(){
		System.out.println("输出英雄机信息:");
		super.show();
		System.out.println("速度:"+step);
		System.out.println("生命值:"+life);
		System.out.println("火力值:"+doubleFire);
	}
	//英雄机随鼠标移动的方法
	//x:鼠标的x轴，y:鼠标的y
	public void moveTo(int x,int y){
		//让英雄机的x坐标y坐标和鼠标同步
		this.x = x - this.width/2;
		this.y = y - this.height/2;
	}
	//英雄机依靠step方法切换图片
	public void step() {
		System.out.println("切换图片");
	}
	//英雄机切换图片
	int index = 0;
	public BufferedImage getImage() {
		index++;
		return images[index%images.length];
		//index是变化的，images.length固定为2
	}
	//英雄机开炮方法
	//由于可能发射一发或两发子弹，故返回子类类型数组
	public Bullet[] shoot(){
		Bullet[] bs = null;
		//获得英雄机宽度的四分之一，方便定义子弹出现的x位置
		int q = this.width/4;
		if(doubleFire>0){//双管子弹
			bs = new Bullet[2];//返回值初始化为长度2的数组
			bs[0] = new Bullet(this.x+q,this.y);
			bs[1] = new Bullet(this.x+q*3,this.y);
			doubleFire--;
		}else{//单管子弹
			bs = new Bullet[1];//返回初始化长度为1的数组
			bs[0] = new Bullet(this.x+q*2,this.y);
		}
		return bs;
	}
	//英雄机加生命
	public void addLife(){
		life++;//加一条命
	}
	//英雄机加火力
	public void addDoubleFire(){
		doubleFire+=20;//加20次火力值
	}
	//获得英雄机的生命数
	public int getLife(){
		return life;//返回英雄机生命数
	}
	//英雄机减命
	public void subLife(){
		life--;//减一条命
	}
	//清空英雄机火力值
	public void clearDoubleFire(){
		doubleFire = 0;
	}
}

Sky 天空

package com.szh;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
public class Sky extends FlyingObject{
//天空
	private static BufferedImage image;
	static{
		image = readImage("background.png");
	}
	private int y1;//第二个天空图案的坐标
	private int step;
	public Sky(){
		super(World.WIDTH,World.HEIGHT,0,0);
		y1 = -height;//第二张图在游戏开始时在负屏幕高度的位置
		step = 5;//以最慢的速度向下移动
	}
	public void show(){
		System.out.println("输出天空信息:");
		super.show();
		System.out.println("y1:"+y1);
		System.out.println("速度:"+step);
	}
	//天空移动
	public void step() {
		y+= step;
		y1+= step;
		//如果y天空出界，将其置于y1天空上方
		if(y>=World.HEIGHT){
			y=-World.HEIGHT;
		}
		//如果y1天空出界，将其置于y1天空上方
		if(y1>=World.HEIGHT){
			y1=-World.HEIGHT;
		}
	}
	//天空图片获取
	public BufferedImage getImage() {
		return image;
	}
	//重写父类中的画图方法
	public void paintObject(Graphics g) {
		g.drawImage(getImage(),x,y,null);
		g.drawImage(getImage(),x,y1,null);
	}
}

FlyingObject 飞行物父类

package com.szh;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.*;
import javax.imageio.ImageIO;
public abstract class FlyingObject {
	//每个飞行物都有三种状态
	public static final int LIFE = 0;//活着
	public static final int DEAD = 1;//死了
	public static final int REMOVE = 2;//消失
	//添加一个属性代表当前飞行物的状态
	protected int state = LIFE;
	//提取出来简化代码，减少代码冗余
	protected int width;
	protected int height;
	protected int x;
	protected int y;
	public FlyingObject() {
	}
	//小敌机，大敌机，小蜜蜂
	public FlyingObject(int width,int height){
		Random ran = new Random();
		this.width = width;
		this.height = height;
		y = -height;//-height
		x = ran.nextInt(World.WIDTH-width);
	}
	//英雄机，子弹，天空
	public FlyingObject(int width, int height, int x, int y) {
		this.width = width;
		this.height = height;
		this.x = x;
		this.y = y;
	}
	//显示信息方法
	public void show(){
		//System.out.println("单位信息");
		System.out.println("宽:"+width+" 高:"+height);
		System.out.println("x:"+x+" y:"+y);
	}
	//飞行物移动方法
	public abstract void step();
	//读取图片
	public static BufferedImage readImage(String fileName){
		//try catch处理异常
		try{
			BufferedImage img = ImageIO.read(FlyingObject.class.getResource(fileName));
			//读取图片
			return img;
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException();
		}
	}
	//每个飞行物都能获得自己的图片，但是具体获得哪张不知道
	//所以定义一个抽象方法，让子类自己去获得图片
	public abstract BufferedImage getImage();
	//对应三种状态，编写三个判断，判断是否是这个状态
	//判断活着
	public boolean isLife(){
		return state == LIFE;
	}
	//判断死了
	public boolean isDead(){
		return state == DEAD;
	}
	//判断离场
	public boolean isRemove(){
		return state == REMOVE;
	}
	//将图片绘制到窗体上
	public void paintObject(Graphics g){
		g.drawImage(getImage(),x,y,null);
	}
	//检测越界方法
	public boolean outOfBounds(){
		//如果飞行物的y轴大于窗体的高，视为越界
		return this.y>World.HEIGHT;
	}
	//飞行物死亡方法
	public void goDead(){
		//将当前飞行物的状态修改为DEAD
		state = DEAD;
	}
	//检测飞行物碰撞的方法
	//当前对象即this表示敌机，目标对象是以参数传递（子弹盒英雄机）
	public boolean hit(FlyingObject other){
		int x1 = this.x - other.width;//敌人的x-子弹的宽
		int x2 = this.x + this.width;//敌人的x+自己的宽
		int y1 = this.y - other.height;//敌人的y-子弹的高
		int y2 = this.y + this.height;//敌人的y+敌人的高
		int x = other.x;    //子弹的x
		int y =other.y;     //子弹的y
		//x的位置在x1和x2之间，y的位置在y1和y2之间，就是击中了
		return x>x1 && x<x2 && y>y1 && y<y2;
	}
}

Award 奖励接口

package com.szh;
//奖励接口
public interface Award {
	int DOUBLE_FIRE = 0; //0为奖励火力值
	int LIFE = 1;        //1为奖励生命值
	//获得奖励的方法
	public int getAwardType();
}

Score 得分接口

package com.szh;
//得分接口
public interface Score {
	//得分方法
	public int getScore();
}

World

package com.szh;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class World extends JPanel{
	private static BufferedImage start;//开始图片
	private static BufferedImage pause;//暂停图片
	private static BufferedImage gameover;//结束图片
	static{
		//将三个图片读取到图片对象中
		start = FlyingObject.readImage("start.png");
		pause = FlyingObject.readImage("pause.png");
		gameover = FlyingObject.readImage("gameover.png");
	}
	public static final int WIDTH = 480;//400
	public static final int HEIGHT = 700;//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 int score;    //游戏的分数
	//声明游戏中只有一个 对象的类型
	Hero hero = new Hero();
	Sky sky = new Sky();
	//声明游戏中存在的引用类型数组
	FlyingObject[] enemy = {
			new AirPlane(),
			new BigAirPlane(),
			new Bee()
	};
	Bullet[] bullets = {
			new Bullet(240,300)
	};
//游戏开始方法
	public void Start(){
		//创建一个监听对象
		MouseAdapter ad = new MouseAdapter(){
			//匿名内部类监听鼠标
			public void mouseMoved(MouseEvent e) {
				int x = e.getX();//获得鼠标所在x轴
				int y = e.getY();//获得鼠标所在y轴
				//让英雄机移动到该位置
				if(state ==RUNNING){
					hero.moveTo(x, y);
				}
			}
			//监听鼠标点击事件
			public void mouseClicked(MouseEvent e) {
				switch(state){
				case START://如果是游戏开始时，点击鼠标
					state = RUNNING;//游戏进入运行状态
					break;
				case GAME_OVER://如果是游戏结束状态
					state = START;//将状态改为开始
					//重置游戏窗口
					score = 0;
					hero = new Hero();
					sky = new Sky();
					enemy = new FlyingObject[0];
					bullets = new Bullet[0];
					break;
				}
			}
			//监听鼠标移出事件
			public void mouseExited(MouseEvent e) {
				//如果游戏运行时，鼠标移出
				if(state == RUNNING){
					state = PAUSE;//进入暂停状态
				}
			}
			//监听鼠标移入事件
			public void mouseEntered(MouseEvent e) {
				//如果游戏在暂停状态时鼠标移入
				if(state == PAUSE){
					state = RUNNING;//游戏继续
				}
			}
		};
		//监听器注册窗口事件，鼠标移动时
		this.addMouseListener(ad);
		this.addMouseMotionListener(ad);
		
		//游戏的主计时器
		Timer timer = new Timer();
		//定义计时器的时间间隔
		int interval = 50;
		TimerTask task = new TimerTask(){
			public void run(){
				//如果游戏在运行状态
				if(state == RUNNING){
					stepAction();//开始移动
					enterAction();//敌人进场
					shootAction();//子弹进场
					outOfBoundsAction();//移除越界内容
					bulletHitAction();//子弹碰撞敌机
					heroHitAction();//英雄机撞敌机
					checkGameOverAction();//检测英雄机生命值，为0的时候结束
				}
				repaint();//重新绘制整个窗体
			}
		};
		//启动计时器
		timer.schedule(task, interval, interval);
	}
//飞行物移动
	public void stepAction(){
		//计时器会没隔指定时间运行这个方法
		//天空移动
		sky.step();
		//遍历敌机数组
		for(int i=0;i<enemy.length;i++){
			//每个敌机移动
			enemy[i].step();
		}
		//遍历子弹数组
		for(int i=0;i<bullets.length;i++){
			bullets[i].step();
		}
	}
//删除越界内容（敌机、子弹）的方法
	public void outOfBoundsAction(){//计时器周期调用
		int index = 0;//统计没有越界敌人的个数和下标
		//创建一个新数组，存放没有越界的敌人
		FlyingObject[] lives = new FlyingObject[enemy.length];
		for(int i=0;i<enemy.length;i++){//遍历原数组
			if(!enemy[i].outOfBounds() && !enemy[i].isRemove()){//如果没出界并且没有移除
				//将没有出界的敌机放入新数组
				lives[index] = enemy[i];
				index++;//敌人总数/新下标自增
			}
		}
		//将保存着没有出界敌机的新数组再赋给enemy
		enemy = Arrays.copyOf(lives, index);
		index = 0;//index清零
		Bullet[] bs = new Bullet[bullets.length];
		for(int i=0;i<bullets.length;i++){
			if(!bullets[i].outOfBounds() && !bullets[i].isRemove()){
				bs[index] = bullets[i];
				index++;
			}
		}
		bullets = Arrays.copyOf(bs, index);
	}
//子弹与敌机碰撞方法
	public void bulletHitAction(){
		//遍历所有子弹
		for(int i=0;i<bullets.length;i++){
			//获得当前遍历的子弹，一遍后面代码使用
			Bullet b = bullets[i];
			//遍历所有敌机
			for(int j=0;j<enemy.length;j++){
				//获得当前遍历的敌人
				FlyingObject f = enemy[j];
				//子弹活着，敌人活着，而且撞上了
				if(b.isLife() && f.isLife() && f.hit(b)){
					//方法的目的就是要在碰撞后操作
					b.goDead();//子弹去死
					f.goDead();//敌机去死
					//判断被集中的是不是小敌机大敌机
					if(f instanceof Score){
						//如果f是实现了Score接口的对象
						Score s =(Score)f;//强制类型转换为Score
						score +=s.getScore();//加分
					}
					//如果击中的是小蜜蜂
					if(f instanceof Award){
						//强制类型转换
						Award a = (Award)f;
						int type = a.getAwardType();//获得奖励类型的值
						switch(type){//开始分支判断
						case Award.DOUBLE_FIRE://如果是奖励火力值
							hero.addDoubleFire();//英雄机加火力值
							break;
						case Award.LIFE://如果奖励生命值
							hero.addLife();//英雄机加生命值
							break;
						}
					}
				}
			}
		}
	}
//英雄机和敌机的碰撞检测
	public void heroHitAction(){
		//遍历所有敌机
		for(int i=0;i<enemy.length;i++){
			//取出当前敌机
			FlyingObject f = enemy[i];
			//检查是否发生碰撞
			if(hero.isLife() && f.isLife() && f.hit(hero)){
				//敌机死
				f.goDead();
				hero.subLife();//英雄机减命
				hero.clearDoubleFire();//英雄机清空火力
			}
		}
	}
//检测游戏结束
	public void checkGameOverAction(){
		//如果英雄机生命为0
		if(hero.getLife()==0){
			state = GAME_OVER;//游戏结束
			}
	}
//生成敌机的方法
	public FlyingObject nextEnemy(){
		FlyingObject fly = null;//声明返回值
		Random ran = new Random();
		int num = ran.nextInt(100);//生成随机数
		if(num<40){//40%几率
			fly = new AirPlane();
		}else if(num<80){//40%几率
			fly = new BigAirPlane();
		}else{//20%几率
			fly = new Bee();
		}
		return fly;
	}
//敌机进场
	//进场计数变量
	int enter = 0;
	public void enterAction(){
		enter++;//每次运行该方法，计数器加一
		if(enter%15==0){
			FlyingObject fly = nextEnemy();//生成一架敌机
			//要把现在的敌人数组扩容
			enemy = Arrays.copyOf(enemy, enemy.length+1);
			//{敌机,敌机,敌机,null}
			//将新生成的敌机放入扩容后数组中最后的新空位
			enemy[enemy.length-1] = fly;
		}
	}
//子弹进场方法
	int shoot = 0;
	public void shootAction(){
		shoot++;
		if(shoot%5 == 0){
			//获得英雄机发射的子弹
			Bullet[] bs = hero.shoot();
			//数组扩容，扩容长度为英雄机发射子弹数量
			bullets = Arrays.copyOf(bullets, bullets.length+bs.length);
			System.arraycopy(bs, 0, bullets, bullets.length-bs.length, bs.length);
			/*if(bs.length == 1){//如果英雄机发射单管炮
				bullets[bullets.length-1] = bs[0];
			}else if(bs.length==2){
				bullets[bullets.length-2] = bs[0];
				bullets[bullets.length-1] = bs[1];
			}*/
		}
	}
//触发所有绘制内容，绘制窗口
	//方法名不能出错，这个方法将在窗口出现时，自动被调用
	public void paint(Graphics g){
		sky.paintObject(g);//画天空
		hero.paintObject(g);//画英雄机
		for(int i=0;i<enemy.length;i++){
			enemy[i].paintObject(g);//画敌机
		}
		for(int i=0;i<bullets.length;i++){
			bullets[i].paintObject(g);//画子弹
		}
		//将分数显示在窗体上
		g.drawString("SCORE"+score, 10, 20);
		//将生命值显示在窗体上
		g.drawString("LIFE"+hero.getLife(), 10, 45);
		//根据状态画图片
		switch(state){
		case START:
			g.drawImage(start,210,300,null);
			break;
		case PAUSE:
			g.drawImage(pause,210,300,null);
			break;
		case GAME_OVER:
			g.drawImage(gameover,80,300,null);
			break;
		}
	}
	public static void main(String[] args) {
		World w = new World(); 
		//创建一个窗口，标题为Fly
		JFrame frame = new JFrame("Fly");
		//将world对象放入窗口
		frame.add(w);
		//设置窗口的宽高
		frame.setSize(World.WIDTH,World.HEIGHT);
		//设置窗口关闭时程序结束
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//设置窗口居中
		frame.setLocationRelativeTo(null);
		//窗口显示
		frame.setVisible(true);//自动调用paint
		w.Start();
	}
}