Java学习-第一部分-第二阶段-项目实战：坦克大战1

坦克大战【1】

笔记目录：(https://www.cnblogs.com/wenjie2000/p/16378441.html)
坦克大战游戏演示

为什么写这个项目
✔好玩
✔涉及到java各个方面的技术

• java面向对象编程
  
• 多线程
  
• 文件i/o操作
  
• 数据库
  

✔巩固旧知识,学习新知识
写项目前的提醒

• 编写坦克大战游戏，你需要有一定的java基础，是完全可以听懂的，最核心的部分一起完成。
  
• 记住一点:成为一个编程高手的秘诀就是:思考------编程-----思考------编程
  

如何讲解这个项目,授课的原则:

• 努力做到通俗易懂。
  
• 宁肯罗嗦一点,也不遗漏细节。
  
• 项目是从小到大的过程,每个完整的项目被分解成不同的版本,从1.0到1.1.….最后版，随版本的增加,将新的功能和新的知识点融入到项目中，整个过程是循序渐进的。让大家轻松的学习,高效的掌握java技术。
  
  

java绘图坐标体系

●坐标体系-介绍
下图说明了Java坐标系。坐标原点位于左上角，以像素为单位。在Java坐标系中,第一个是x坐标,表示当前位置为水平方向,距离坐标原点x个像素;第二个是y坐标，表示当前位置为垂直方向，距离坐标原点y个像素。

坐标体系-像素

• 绘图还必须要搞清一个非常重要的概念-像素个个像素等于多少厘米?
  
• 计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行,整个计算机屏幕共有480 000个像素。像素是一个密度单位,而厘米是长度单位,两者无法比较
  

java绘图技术

介绍-快速入门
先给大家写一个小案例,在面板上画一个小圆,然后借这个案例，来讲解java绘图技术原理。

1. import javax.swing.*;
2. import java.awt.*;
4. public class DrawCircle extends JFrame {//JFrame对应窗口,可以理解成是一个画框
5.     //定义一个面板
6.     private MyPanel mp = null;
7.     public static void main(String[] args) {
8.         new Te();
9.         System.out.println("退出程序...");
10.     }
11.     public DrawCircle() {//构造器
12.         //初始化面板
13.         mp = new MyPanel();
14.         //把面板放入到窗口(画框)
15.         this.add(mp);
16.         //设置窗口的大小
17.         this.setSize(400,300);
18.         ///当点击窗口的小x，程序完全退出.
19.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
20.         this.setVisible(true);//可以显示
21.     }
22. }
24. //1.先定义一个MyPanel，继承JPanel类，画图形，就在面板上画
25. class MyPanel extends JPanel {
26.     //说明:
27.     //1.MyPanel对象就是一个画板
28.     //2.Graphics g把g理解成一支画笔
29.     //3.Graphics提供了很多绘图的方法
30.     //Graphics g
31.     @Override
32.     public void paint(Graphics g) {//绘图方法
33.         super.paint(g);//调用父类的方法完成初始化
34.         System.out.println("调用了paint方法");
35.         //画出一个圆形.
36.         g.drawOval(10, 10, 100, 100);
37.     }
38. }

复制代码

绘图原理
✔Component类提供了两个和绘图相关最重要的方法:

• paint(Graphics g)绘制组件的外观
  
• repaint()刷新组件的外观。
  

✔当组件第一次在屏幕显示的时候,程序会自动的调用paint()方法来绘制组件。
✔在以下情况paint()将会被调用:

• 窗口最小化再最大化
  
• 窗口的大小发生变化
  
• repaint方法被调用
  

✔思考题:如何证明上面的三种情况,会调用paint()方法
Graphics类
Graphics类你可以理解就是画笔,为我们提供了各种绘制图形的方法:[参考jdk帮助文档]

• 画直线drawLine(int x1,int y1,int x2,int y2)
  
• 画矩形边框drawRect(int x, int y, int width, int height)
  
• 画椭圆边框drawOval(int x, int y, int width, int height)
  
• 填充矩形 fillRect(int x, int y, int width, int height)
  
• 填充椭圆fillOval(int x, int y, int width, int height)
  
• 画图片drawlmage(lmage img, int x, int y, ..)
  
• 画字符串drawString(String str, int x, int y)
  
• 设置画笔的字体setFont(Font font)
  
• 设置画笔的颜色setColor(Color c)
  

1. import javax.swing.*;
2. import java.awt.*;
5. public class DrawCircle extends JFrame {//JFrame对应窗口,可以理解成是一个画框
6.     //定义一个面板
7.     private MyPanel mp = null;
8.     public static void main(String[] args) {
9.         new Te();
10.         System.out.println("退出程序...");
11.     }
12.     public DrawCircle() {//构造器
13.         //初始化面板
14.         mp = new MyPanel();
15.         //把面板放入到窗口(画框)
16.         this.add(mp);
17.         //设置窗口的大小
18.         this.setSize(400,300);
19.         ///当点击窗口的小x，程序完全退出.
20.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
21.         this.setVisible(true);//可以显示
22.     }
23. }
25. //1.先定义一个MyPanel，继承JPanel类，画图形，就在面板上画
26. class MyPanel extends JPanel {
27.     //说明:
28.     //1.MyPanel对象就是一个画板
29.     //2.Graphics g把g理解成一支画笔
30.     //3.Graphics提供了很多绘图的方法
31.     //Graphics g
32.     @Override
33.     public void paint(Graphics g) {//绘图方法
34.         super.paint(g);//调用父类的方法完成初始化
35.         System.out.println("调用了paint方法");
37.         //演示绘制不同的图形..
38.         //1. 画直线drawLine(int x1,int y1,int x2,int y2)
39. //        g.drawLine(10,10,100,100);
40.         //2. 画矩形边框drawRect(int x, int y, int width, int height)
41. //        g.drawRect(10,10,100,100);
42.         //3. 画椭圆边框drawOval(int x, int y, int width, int height)
43. //        g.drawOval(10, 10, 100, 100);
44.         //4. 填充矩形 fillRect(int x, int y, int width, int height)
45. //        g.setColor(Color.BLUE);
46. //        g.fillRect(10,10,100,100);
47.         //5. 填充椭圆fillOval(int x, int y, int width, int height)
48. //        g.setColor(Color.red);
49. //        g.fillOval(10,10,100,100);
50.         //6. 画图片drawlmage(lmage img, int x, int y, ..)
51. //        Image image = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/张文杰.jpg"));
52. //        g.drawImage(image,10,10,150,200,this);
53.         //7. 画字符串drawString(String str, int x, int y)
54. //        g.setColor(Color.red);
55. //        g.setFont(new Font("行书",Font.BOLD,50));
56. //        g.drawString("你好",100,50);//x,y对应字符串左下角位置
57.         //8. 设置画笔的字体setFont(Font font)
58.         //9. 设置画笔的颜色setColor(Color c)
59.     }
60. }

复制代码

绘出坦克
坦克大战游戏中，我们会用到坦克，现在我们就利用java绘图技术来画出一个小坦克,完成我们的坦克大战游戏1.0版本!

Tank//坦克位置

1. public class Tank {
2.     //坦克左上角坐标
3.     private int x;
4.     private int y;
6.     public Tank(int x, int y) {
7.         this.x = x;
8.         this.y = y;
9.     }
11.     public int getX() {
12.         return x;
13.     }
15.     public void setX(int x) {
16.         this.x = x;
17.     }
19.     public int getY() {
20.         return y;
21.     }
23.     public void setY(int y) {
24.         this.y = y;
25.     }
26. }

复制代码

Hero//玩家坦克

1. public class Hero extends Tank{
2.     public Hero(int x, int y) {
3.         super(x, y);
4.     }
5. }

复制代码

MyPanel//面板

1. import javax.swing.*;
2. import java.awt.*;
4. public class MyPanel extends JPanel {
5.     Hero hero=null;//定义我的坦克
6.     public MyPanel(){
7.         hero=new Hero(100,100);//初始化自己的坦克位置
8.     }
10.     @Override
11.     public void paint(Graphics g) {
12.         super.paint(g);
13.         g.fillRect(0,0,1000,750);//黑色背景
15.         //画出坦克
16.         drawTank(hero.getX(),hero.getY(),g,0,1);
17.     }
19.     /**
20.      *
21.      * @param x 坦克左上角x坐标
22.      * @param y 坦克左上角y坐标
23.      * @param g 画笔
24.      * @param direct 坦克方向（上下左右）
25.      * @param type 坦克类型
26.      */
27.     public void drawTank(int x,int y,Graphics g,int direct,int type){
29.         switch (type){
30.             case 0://我们的坦克
31.                 g.setColor(Color.cyan);
32.                 break;
33.             case 1://敌人的坦克
34.                 g.setColor(Color.yellow);
35.                 break;
36.         }
37.         //根据坦克方向，绘制坦克
38.         switch (direct){
39.             case 0://向上
40.                 g.fill3DRect(x,y,10,60,false);//画出坦克左边轮子
41.                 g.fill3DRect(x+30,y,10,60,false);//画出坦克右边轮子
42.                 g.fill3DRect(x+10,y+10,20,40,false);//画出坦克盖子
43.                 g.fillOval(x+10,y+20,20,20);//画出圆形盖子
44.                 g.drawLine(x+20,y+30,x+20,y);//画出炮筒
45.                 break;
46.             case 1:
47.             case 2:
48.             case 3:
49.         }
50.     }
51. }

复制代码

HspTankGame01//窗体

1. import javax.swing.*;
3. public class HspTankGame01 extends JFrame {
4.     MyPanel mp=null;
5.     public static void main(String[] args) {
6.         new HspTankGame01();
7.     }
9.     public HspTankGame01() {
10.         mp=new MyPanel();
11.         this.add(mp);
12.         this.setSize(1000,750);
13.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14.         this.setVisible(true);
15.     }
16. }

复制代码

java事件处理机制

事件处理机制-看个问题
请大家看一个小程序。(BallMove.java)怎样让小球受到键盘的控制,上下左右移动.

1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.KeyEvent;
4. import java.awt.event.KeyListener;
6. public class BallMove extends JFrame{//窗口
7.     MyPanel mp=null;
8.     public static void main(String[] args) {
9.         new BallMove();
10.     }
11.     public BallMove(){
12.         mp=new MyPanel();
13.         this.add(mp);
14.         this.setSize(400,300);
15.         //窗口JFrame对象可以监听键盘事,即可以监听到面板发生的键盘事件
16.         this.addKeyListener(mp);
17.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18.         this.setVisible(true);
19.     }
20. }
22. //面板，可以画出小球
23. //KeyListener是监听器，可以监听键盘事件
24. class MyPanel extends JPanel implements KeyListener {
25.     //为了让小球可以移动，把他的左上角的坐标(x,y)设置变量
26.     int x = 10;
27.     int y =10;
28.     @Override
29.     public void paint(Graphics g) {
30.         super.paint(g);
31.         g.fillOval(x,y,20,20);
32.     }
34.     //有字符输出，该方法就会触发
35.     @Override
36.     public void keyTyped(KeyEvent e) {
38.     }
40.     //当某个键按下，该方法触发
41.     @Override
42.     public void keyPressed(KeyEvent e) {
43.         //System.out.println((char)e.getKeyCode()+"被按下");
45.         //根据用户按下的不同键，来处理小球的移动(上下左右)
46.         //在java中，会给每一个键，分配一个值(int)
47.         if(e.getKeyCode()==KeyEvent.VK_DOWN){//KeyEvent.VK_DOWN就是向下的箭头对应的code
48.             y++;
49.         }else if (e.getKeyCode()==KeyEvent.VK_UP){
50.             y--;
51.         }else if(e.getKeyCode()==KeyEvent.VK_RIGHT){
52.             x++;
53.         }else if(e.getKeyCode()==KeyEvent.VK_LEFT){
54.             x--;
55.         }
56.         //让面板重绘
57.         this.repaint();
58.     }
60.     //当某个键松开，被触发
61.     @Override
62.     public void keyReleased(KeyEvent e) {
64.     }
65. }

复制代码

基本说明
java事件处理是采取"委派事件模型"。当事件发生时,产生事件的对象,会把此"信息”传递给"事件的监听者"（例：KeyListener）处理，这里所说的“信息"实际上就是java.awt.event事件类库里某个类所创建的对象,把它称为"事件的对象"(例：KeyEvent)。
请大家看一个示意图:

事件处理机制深入理解

• 前面我们提到几个重要的概念事件源，事件,事件监听器我们下面来全面的介绍它们。
  
• 事件源:事件源是一个产生事件的对象，比如按钮，窗回等。
  
• 事件:事件就是承载事件源状态改变时的对象，比如当键盘事件、鼠标事件、窗口事件等等，会生成一个事件对象，该对象保存着当前事件很多信息，比如KeyEvent对象有含义被按下键的Code值。java.awt.event包和javax.swing.event包中定义了各种事件类型
  
• 事件类型:查阅jdk文档
  

• 事件监听器接口:
  (1)当事件源产生一个事件，可以传送给事件监听者处理
  (2)事件监听者实际上就是一个类,该类实现了某个事件监听器接口比如前面我们案例中的MyPanle就是一个类,它实现了KeyListener接口，它就可以作为一个事件监听者,对接受到的事件进行处理
  (3)事件监听器接口有多种，不同的事件监听器接口可以监听不同的事件,一个类可以实现多个监听接口
  (4)这些接口在java.awt.event包和javax.swing.event包中定义。列出常用的事件监听器接口,查看jdk文档聚集了.
  

坦克大战游戏(1.0版)

绘制己方坦克（能够使用WASD移动）
绘制敌方坦克（颜色有差别，至少3个）//要想敌人的坦克移动，需要下一节的线程知识
Tank//坦克

1. package tankgame02;
3. public class Tank {
4.     //坦克左上角坐标
5.     private int x;
6.     private int y;
7.     private int direct;//坦克方向 0上 1右 2下 3左
9.     public int getSpeed() {
10.         return speed;
11.     }
13.     public void setSpeed(int speed) {
14.         this.speed = speed;
15.     }
17.     private int speed=1;//坦克速度
19.     //上右下左移动方法
20.     public void moveUp(){
21.         y-=speed;
22.     }
23.     public void moveDown(){
24.         y+=speed;
25.     }
26.     public void moveLeft(){
27.         x-=speed;
28.     }
29.     public void moveRight(){
30.         x+=speed;
31.     }
33.     public int getDirect() {
34.         return direct;
35.     }
37.     public void setDirect(int direct) {
38.         this.direct = direct;
39.     }
41.     public Tank(int x, int y) {
42.         this.x = x;
43.         this.y = y;
44.     }
46.     public int getX() {
47.         return x;
48.     }
50.     public void setX(int x) {
51.         this.x = x;
52.     }
54.     public int getY() {
55.         return y;
56.     }
58.     public void setY(int y) {
59.         this.y = y;
60.     }
61. }

复制代码

Hero//己方坦克

1. package tankgame02;
3. public class Hero extends Tank {
4.     public Hero(int x, int y) {
5.         super(x, y);
6.     }
7. }

复制代码

EnemyTank//敌方坦克

1. package tankgame02;
3. public class EnemyTank extends Tank{
4.     public EnemyTank(int x, int y) {
5.         super(x, y);
6.     }
7. }

复制代码

MyPanel//面板

1. package tankgame02;
3. import javax.swing.*;
4. import java.awt.*;
5. import java.awt.event.KeyEvent;
6. import java.awt.event.KeyListener;
7. import java.util.Hashtable;
8. import java.util.Vector;
10. ////为了监听键盘事件，实现KeyListener
11. public class MyPanel extends JPanel implements KeyListener {
12.     Hero hero = null;//定义我的坦克
13.     Vector<EnemyTank> enemyTanks = new Vector<>();//定义敌人坦克
14.     int enemyTankSize = 3;
16.     public MyPanel() {
17.         hero = new Hero(100, 100);//初始化自己的坦克位置
18.         for (int i = 0; i < enemyTankSize; i++) {//初始化敌人的坦克位置
19.             enemyTanks.add(new EnemyTank(100 * (i + 1), 0));
20.         }
22. //        hero.setSpeed(5);
23.     }
25.     @Override
26.     public void paint(Graphics g) {
27.         super.paint(g);
28.         g.fillRect(0, 0, 1000, 750);//黑色背景
30.         //画出坦克
31.         drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 0);
33.         //画出敌人坦克
34.         for (int i = 0; i < enemyTankSize; i++) {
35.             //取出坦克
36.             EnemyTank enemyTank = enemyTanks.get(i);
37.             enemyTank.setDirect(2);
38.             drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
39.         }
40.     }
42.     /**
43.      * @param x      坦克左上角x坐标
44.      * @param y      坦克左上角y坐标
45.      * @param g      画笔
46.      * @param direct 坦克方向（上下左右）
47.      * @param type   坦克类型
48.      */
49.     public void drawTank(int x, int y, Graphics g, int direct, int type) {
51.         switch (type) {
52.             case 0://我们的坦克
53.                 g.setColor(Color.cyan);
54.                 break;
55.             case 1://敌人的坦克
56.                 g.setColor(Color.yellow);
57.                 break;
58.         }
59.         //根据坦克方向，绘制坦克
60.         switch (direct) {
61.             case 0://向上
62.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边轮子
63.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边轮子
64.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克盖子
65.                 g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
66.                 g.drawLine(x + 20, y + 30, x + 20, y);//画出炮筒
67.                 break;
68.             case 1://右
69.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);//画出坦克左边轮子
70.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);//画出坦克右边轮子
71.                 g.fill3DRect(x, y + 20, 40, 20, false);//画出坦克盖子
72.                 g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
73.                 g.drawLine(x + 20, y + 30, x + 50, y + 30);//画出炮筒
74.                 break;
75.             case 2://下
76.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边轮子
77.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边轮子
78.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克盖子
79.                 g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
80.                 g.drawLine(x + 20, y + 30, x + 20, y + 60);//画出炮筒
81.                 break;
82.             case 3://左
83.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);//画出坦克左边轮子
84.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);//画出坦克右边轮子
85.                 g.fill3DRect(x, y + 20, 40, 20, false);//画出坦克盖子
86.                 g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
87.                 g.drawLine(x + 20, y + 30, x + -10, y + 30);//画出炮筒
88.                 break;
89.         }
91.     }
93.     @Override
94.     public void keyTyped(KeyEvent e) {
96.     }
98.     //处理WDSA键按下情况
99.     @Override
100.     public void keyPressed(KeyEvent e) {
101.         if (e.getKeyCode() == KeyEvent.VK_W) {
102.             //改变坦克方向
103.             hero.setDirect(0);
104.             //修改坦克坐标
105.             hero.moveUp();
106.         } else if (e.getKeyCode() == KeyEvent.VK_D) {
107.             hero.setDirect(1);
108.             hero.moveRight();
109.         } else if (e.getKeyCode() == KeyEvent.VK_S) {
110.             hero.setDirect(2);
111.             hero.moveDown();
112.         } else if (e.getKeyCode() == KeyEvent.VK_A) {
113.             hero.setDirect(3);
114.             hero.moveLeft();
115.         }
116.         this.repaint();
117.     }
119.     @Override
120.     public void keyReleased(KeyEvent e) {
122.     }
123. }

复制代码

HspTankGame02//窗体

1. package tankgame02;
3. import javax.swing.*;
5. public class HspTankGame02 extends JFrame {
6.     MyPanel mp=null;
7.     public static void main(String[] args) {
8.         new HspTankGame02();
9.     }
11.     public HspTankGame02() {
12.         mp=new MyPanel();
13.         this.add(mp);
14.         this.setSize(1000,750);
15.         this.addKeyListener(mp);
16.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17.         this.setVisible(true);
18.     }
19. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！