java游戏小项目：飞机大战简化版（面向对象深入理解）

        java学习的路线，从最开始的基本知识（差不多到数组），下一关就是面向对象的理解，其实对于大多数人来说，前面的知识比如基本数据类型，控制语句等等，都是太基础了，对比C、Python等其他各种语句，其实都是大同小异的，而学到面向对象，就会开始从入门到此刻放弃

       首先还是先说一下到底是什么是面向对象，这里不得不提的另一个概念就是面向对象。首先我们要明确，面向对象和面向过程都是对软件分析、设计和开发的一种方法。

       面向过程思想是在思考问题时按照步骤去实现，并将步骤对应成方法，一步一步，最终完成。这样的思想其实适合简单的任务，不要求过多的协作的情况。比如：如何开车这一问题，按照面向过程，就是1、打开车门，进入车内2、调整座椅、系好安全带.......（具体的步骤我就不详细说了，大家考驾驶证科二的时候都有丰富的经验）

       而面对如何造车这样复杂的问题，面向对象就显得重要了。面向对象是在思考问题时，按照如果设计这个东西，他都包含什么零件，比如：如何造车，那就是车轱辘，发动机，车窗....等等等（这个具体我也不说了，一个女孩子，其实我也说不出来啥），而面向对象则适合解决复杂些的问题，各个部件互相协作，沟通较多的问题。

       这里我今天分享的是飞机小项目，其实就是low版的飞机大战，这一项目其实是对面向对象知识的深入，主要的就是理会java的继承，从Object的基类，然后实现plane类，shell类，但是代码里也加入了一些 容器，Date类，窗口类，等等，代码注释改写的我都已经写出来了，如果有什么问题，大家可以私信

       这是具体代码书写的一个过程，大家以供参考

一、游戏项目介绍_建立游戏主窗口

1、通过游戏项目学习整个java基础知识体系，游戏是窗口开始的

2、AWT和Swing是Java中常见的GUI（图形用户界面）技术，但是由于java很少用于桌面软件开发，所以，大家无需花时间学习这两门技术。

AWT是java中最老的gui技术，非常简单，但是实际开发中很少用到。本节中，仅限于画出基本的窗口和图形加载。建立java项目。

二、图形绘制_文本绘制_颜色改变_图像对象的加载

三、线程内部类实现动画

1、一个程序想跑起来需要多个线程配合

四、游戏物体根类的实现

1、游戏物体的共性就是：一个img，有坐标x，y，并且有速度，宽度和高度

五、面向对象思想重构飞机类设计

六、键盘控制游戏物体原理

1、键盘和程序交互时，每次按下键，松开键都会触发相应的键盘事件，事件的信息都封装了KeyEvent，每一个键盘都有着标号

七、面向对象重构飞机类的键盘控制代码

八、炮弹类设计_任意角度飞行

九、容器或数组产生多发炮弹

十、双缓冲解决闪烁问题_矩形检测原理

1、继承Jfarme会有轻微的闪烁，Farme会更厉害，所以只能Farme+一个双缓冲技术

2、矩形检测就是希望物体碰撞的时候我可以知道，每一个物体在游戏里都是矩形，要测飞机有没有和子弹碰撞，两个矩形是不是相交，如果相交，那就是掉血

十一、炮弹和飞机的碰撞检测_飞机死掉

十二、爆炸类_图片数组轮播处理

十三、主窗口画出爆炸类

十四、飞机死亡和计时功能

具体代码如下，同时代码也已上传至资源，请自行查看

package cn.sxt.game;

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Date;

import javax.swing.JFrame;



/**
 * 飞机游戏的主窗口
 * @author 24125
 *
 */
public class MyGameFrame extends Frame{//更改了JFrame
	Image planeImg=GameUtil.getImage("images/plane.png");
	Image bg=GameUtil.getImage("images/bg.jpg");
	
	Plane plane = new Plane(planeImg,250,250);
//	生成单个炮弹Shell shell = new Shell();
//	数组方式产生多个炮弹
	Shell[] shells=new Shell[50];
	Explode bao ;
	//创建时间对象，就是毫秒数
	Date startTime=new Date();
	Date endTime;
	int period;//游戏持续的时间
	@Override
		public void paint(Graphics g) {
		  super.paint(g);//这一步不可缺少，父类会给一个背景
			// 自动被调用，g相当于一支画笔
	Color c=g.getColor();
			g.drawImage(bg, 0, 0, null);
			plane.drawSelf(g);	
			//单个的炮弹shell.draw(g);
			//画出所有的炮弹
			for(int i=0;i<shells.length;i++) {
				shells[i].draw(g);
//				飞机和炮弹的碰撞检测
				boolean peng=shells[i].getRect().intersects(plane.getRect());
				if(peng) {
					plane.live=false;
				
					if(bao==null) {
					
					bao=new Explode(plane.x,plane.y);
					
					endTime=new Date();
				    period=(int)((endTime.getTime()-startTime.getTime())/1000);
					}
					
					bao.draw(g);
			}
				//计时功能，给出提示
				if(!plane.live) {
					
					g.setColor(Color.RED);
					Font f=new Font("宋体",Font.BOLD,50);
					g.setFont(f);
					g.drawString("时间："+period+"秒", (int)plane.x, (int)plane.y);
				}
			
			
		}
			g.setColor(c);
	}
	//这个线程帮助我们反复的重画窗口
	class PaintThread extends Thread{
		@Override
		public void run() {
			super.run();
			while(true) {
				//System.out.println("窗口画一次");
				repaint();//重画
				try {
					Thread.sleep(40);
				} catch (InterruptedException e) {
										e.printStackTrace();
				}//1s=1000ms;1s放24次时人眼看到的是动画
				
				
			}
		}
		
	}
	//定义键盘监听
	class KeyMonitor extends KeyAdapter{

		@Override
		public void keyPressed(KeyEvent e) {
			
			super.keyPressed(e);
			plane.addDirection(e);
		}

		@Override
		public void keyReleased(KeyEvent e) {
			
			super.keyReleased(e);
			plane.minusDirection(e);
		}
	}
	
		
	

	/**
	 * 用于初始化窗口
	 */
	public void launchFrame() {
		this.setTitle("nana");//给游戏加一个标题，这是JFrame里边的方法
		this.setVisible(true);//默认窗口是不可见的，我们这里设置成可见
		this.setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT);//设置大小
		this.setLocation(300,300);//设置一个位置，定的是左上角的位置，从左上角开始，向右为x，向下为y
//		关闭窗口，是假的，关窗口必须要是程序结束并且关上窗口
		this.addWindowListener(new WindowAdapter(){
			@Override
			public void windowClosing(WindowEvent e) {
			System.exit(0);
			}
		});
		new PaintThread().start();//启动重画窗口的线程
		addKeyListener(new KeyMonitor());//给窗口增加键盘的监听
		//初始化50个炮弹
		for(int i=0;i<shells.length;i++) {
			shells[i]=new Shell();
		}
	}
	public static void main(String[] args) {
		MyGameFrame f = new MyGameFrame();
		f.launchFrame();
	}
//	双缓冲
	private Image offScreenImage=null;
	public void update(Graphics g) {
		if(offScreenImage==null)
			offScreenImage=this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT);//这是游戏窗口的宽度
		
		Graphics gOff=offScreenImage.getGraphics();
		paint(gOff);
		g.drawImage(offScreenImage,0,0,null);
		
	}
}

 

package cn.sxt.game;

/**
 * 常量类
 * @author 24125
 *
 */
public class Constant {
	public static final int GAME_WIDTH=500;
	public static final int GAME_HEIGHT=500;

}

package cn.sxt.game;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;

/**
 * 飞机类
 * @author 24125
 *
 */
public class Plane extends GameObject{
	
	boolean left,up,right,down;
	
	boolean live=true;
	public void drawSelf(Graphics g) {
		if(live) {
			//		飞机要动起来，所以重写父类函数
		g.drawImage(img, (int)x, (int)y, null);
		if(left) {
			x-=speed;
		}
		if(right) {
			x+=speed;
		}
		if(up) {
			y-=speed;
		}
		if(down) {
			y+=speed;
		}
//	注意这块的方向，示意着坐标轴的方向
		}
		else {
			System.out.println("死掉了");
		}

		
	}
	public Plane(Image img,double x,double y) {
		this.img=img;
		this.x=x;
		this.y=y;
		this.speed=3;
		this.width=img.getWidth(null);
		this.height=img.getHeight(null);
	}

	public void addDirection(KeyEvent e) {
		switch(e.getKeyCode()) {
		case KeyEvent.VK_LEFT:
			left=true;
			break;
		case KeyEvent.VK_UP:
			up=true;
			break;
		case KeyEvent.VK_RIGHT:
			right=true;
			break;
		case KeyEvent.VK_DOWN:
			down=true;
			break;
		}
	}
	//取消相应方向
	public void minusDirection(KeyEvent e) {
		switch(e.getKeyCode()) {
		case KeyEvent.VK_LEFT:
			left=false;
			break;
		case KeyEvent.VK_UP:
			up=false;
			break;
		case KeyEvent.VK_RIGHT:
			right=false;
			break;
		case KeyEvent.VK_DOWN:
			down=false;
			break;
		}
	}


}

package cn.sxt.game;

import java.awt.Color;
import java.awt.Graphics;

/**
 * 炮弹类
 * @author 24125
 *
 */
public class Shell extends GameObject{
	double degree;
	public Shell() {
		x=200;
		y=200;
		width=10;
		height=10;
		speed=3;
		degree=Math.random()*Math.PI*2;//random随机生成0-1，但是我们这里是弧度，是在0-2PI之间的
				
	}
	public void draw(Graphics g) {
		Color c=g.getColor();//保存开始的颜色最后再还回去
		g.setColor(Color.YELLOW);
		g.fillOval((int)x, (int)y, width, height);
	
//炮弹沿着任意角度去飞		
		x+=speed*Math.cos(degree);
		y+=speed*Math.sin(degree);
//		碰到边界的时候反弹回来
		if(x<0||x>Constant.GAME_WIDTH-width) {
			degree=Math.PI-degree;
		}
		if(y<30||y>Constant.GAME_HEIGHT-height) {
			degree=-degree;
		}
		
		g.setColor(c);
	}

}

package cn.sxt.game;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
 
/**
 * 返回指定路径文件的图片对象
 * @author 24125
 *
 */
public class GameUtil {
    // 工具类最好将构造器私有化。
    private GameUtil() {
     
    } 
 
    public static Image getImage(String path) {
        BufferedImage bi = null;
        try {
            URL u = GameUtil.class.getClassLoader().getResource(path);
            bi = ImageIO.read(u);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bi;
    }
}

package cn.sxt.game;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;

/**
 * 游戏物体的父类
 * @author 24125
 *
 */

public class GameObject {
	Image img;
	double x,y;
	int speed;
	int width,height;
	
	public void drawSelf(Graphics g) {
		g.drawImage(img, (int)x, (int)y, null);
		
	}

	public GameObject(Image img, double x, double y, int speed, int width, int height) {
		super();
		this.img = img;
		this.x = x;
		this.y = y;
		this.speed = speed;
		this.width = width;
		this.height = height;
	}

	public GameObject(Image img, double x, double y) {
		super();
		this.img = img;
		this.x = x;
		this.y = y;
	}
	
	public GameObject() {
		
	}

/**
 * 返回物体所在的矩形，便于后续的碰撞检测，两个游戏物体这么碰撞，都是根据矩形有没有相交来进行判断
 * @author 24125
 *
 */
	public Rectangle getRect() {
		return new Rectangle((int)x,(int)y,width,height);
	}
	

}

package cn.sxt.game;

import java.awt.Graphics;
import java.awt.Image;

public class Explode {
	double x,y;//爆炸的位置
	static Image[] imgs=new Image[16];//静态变量，有的时候会多次爆炸，如果每次都要重新初始化，会很浪费资源
	static {//静态初始化块：直接通过for循环进行加载
		for(int i=0;i<16;i++) {
			imgs[i]=GameUtil.getImage("images/explode/e"+(i+1)+".gif");
			imgs[i].getWidth(null);
		}
	}
	int count;
	public void draw(Graphics g) {
		if(count<=15) {
			g.drawImage(imgs[count], (int)x, (int)y,null);
			count++;
		}
		
	}
	public Explode(double x,double y) {
		this.x=x;
		this.y=y;
		
	}
	

}