一、坦克大战游戏演示

1.1 界面演示

image.png

1.2 为什么写这个项目

  1. 好玩
  2. 涉及到Java各个方面的技术
    1. Java面向对象编程
    2. 多线程
    3. 文件I/O操作
    4. 数据库
  3. 巩固旧知识，学习新知识

1.3 写项目前的提醒

  1. 编写坦克大战游戏，你需要有一 定的java基础，最核心的部分跟着课程学习完成
  2. 记住一点：成为一个编程高手的秘诀就是：思考——编程——思考——-编程

二、Java绘图坐标体系

2.1 坐标体系 - 介绍

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

2.2 坐标体系 - 像素

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

2.3 快速入门

先给大家写一个小案例,在面板上画一个小圆，然后借这个案例，来讲解java绘图技术原理。(DrawCircle.java)

  1. package com.hsp.tank01.zone_;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  */
  10. public class DrawCircle extends JFrame{  //JFrame对应窗口
  11.     //定义一个面板
  12.     private MyPanel mp = null;
  14.     public static void main(String[] args) {
  15.         new DrawCircle();
  16.     }
  18.     public DrawCircle() {  //构造器
  19.         //初始化面板
  20.         mp = new MyPanel();
  21.         //把面板放入到窗口
  22.         this.add(mp);
  23.         //设置窗口的大小
  24.         this.setSize(410,300);
  25.         this.setVisible(true);  //设置窗口为可见
  26.     }
  27. }
  29. //1. 先定义一个MyPanel,继承JPanel类,画图形,就在这个面板上画
  30. class MyPanel extends JPanel {
  32.     //说明：
  33.     //1. MyPanel 对象就是一个画板
  34.     //2. Graphics g 把 g 理解成一支画笔
  35.     //3. Graphics 提供了很多绘图的方法
  36.     @Override
  37.     public void paint(Graphics g) {  //绘图方法
  38.         super.paint(g);  //调用父类方法完成初始化 一定要保留
  39.         //画出一个圆
  40.         System.out.println("paint方法被调用");
  41.         g.drawOval(10,10,100,100);
  42.     }
  43. }

image.png

2.4 绘图原理

Component 类提供了两和绘图相关的最重要的方法：

  1. paint(Graphics g) 绘制组件的外观
  2. repaint() 刷新组件的外观

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

  1. 窗口最小化，再最大化
  2. 窗口的大小发生变化
  3. repaint 方法被调用

思考题：如何证明上面的三种情况，会调用 paint() 方法？

三、Java绘图技术

3.1 Graphics 类

Graphics 类可以理解就是画笔，为我们提供了各种绘制图形的方法【具体参考jdk帮助文档】

  1. 画直线 drawLine(int x1, int y1, int x2, int y2)
  2. 画矩形边框 drawRect(int x, int y, int width, int height)
  3. 画椭圆边框 drawOval(int x, int y, int width, int height)
  4. 填充矩形 fillRect(int x, int y, int width, int height)
  5. 填充椭圆 fillOval(int x, int y, int width, int height)
  6. 画图片 drawImage(Image img, int x, int y, …)
  7. 画字符串 drawString(String str, int x, int y)
  8. 设置画笔的字体 setFont(Font font)
  9. 设置画笔的颜色 setColor(Color c)

3.2 案例演示

  1. package com.hsp.tank01.zone_;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. /**
  7.  * @author HarborGao
  8.  * @version 1.0
  9.  */
  10. public class DrawCircle extends JFrame{  //JFrame对应窗口
  11.     //定义一个面板
  12.     private MyPanel mp = null;
  14.     public static void main(String[] args) {
  15.         new DrawCircle();
  16.     }
  18.     public DrawCircle() {  //构造器
  19.         //初始化面板
  20.         mp = new MyPanel();
  21.         //把面板放入到窗口
  22.         this.add(mp);
  23.         //设置窗口的大小
  24.         this.setSize(410,300);
  25.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //当点击窗口的 × ,就会退出程序
  26.         this.setVisible(true);  //设置窗口为可见
  27.     }
  28. }
  30. //1. 先定义一个MyPanel,继承JPanel类,画图形,就在这个面板上画
  31. class MyPanel extends JPanel {
  33.     //说明：
  34.     //1. MyPanel 对象就是一个画板
  35.     //2. Graphics g 把 g 理解成一支画笔
  36.     //3. Graphics 提供了很多绘图的方法
  37.     @Override
  38.     public void paint(Graphics g) {  //绘图方法
  39.         super.paint(g);  //调用父类方法完成初始化 一定要保留
  40.         //画出一个圆
  41.         //System.out.println("paint方法被调用");
  42. //        g.drawOval(10,10,100,100);
  44.         //演示绘制不同的图形
  45.         //1. 画直线 drawLine(int x1, int y1, int x2, int y2)
  46. //        g.drawLine(10,10,100,100);
  47.         //2. 画矩形边框 drawRect(int x, int y, int width, int height)
  48.         g.drawRect(20,20,100,200);
  49.         //3. 画椭圆边框 drawOval(int x, int y, int width, int height)
  50.         //4. 填充矩形 fillRect(int x, int y, int width, int height)
  51.         g.setColor(Color.BLUE);
  52.         g.fillRect(10,10,100,50);
  53.         //5. 填充椭圆 fillOval(int x, int y, int width, int height)
  54.         g.setColor(Color.red);
  55.         g.fillOval(60,60,60,60);
  56.         //6. 画图片 drawImage(Image img, int x, int y, ...)
  57.             //(1) 获取图片资源 /bg.jpg 表示在该项目的根目录获取 bg.jpg 图片资源
  58.         Image image = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bg.jpg"));
  59.         g.drawImage(image,80,80,150,150,this);
  60.         //7. 画字符串 drawString(String str, int x, int y)  就是写字
  61.         g.setColor(Color.green);
  62.         g.setFont(new Font("隶书",Font.BOLD,30));
  63.         //注意：这里设置的 x y 是字符串的左下角
  64.         g.drawString("北京你好",100,60);
  65.         //8. 设置画笔的字体 setFont(Font font)
  66.         //9. 设置画笔的颜色 setColor(Color c)
  67.     }
  68. }

3.3 绘出坦克

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

  1. 创建坦克类 ```java package com.hsp.tank01.tankgame;

public class Tank { private int x; //坦克的横坐标 private int y; //坦克的纵坐标

  1. public Tank(int x, int y) {
  2.     this.x = x;
  3.     this.y = y;
  4. }
  6. public int getX() {
  7.     return x;
  8. }
  10. public void setX(int x) {
  11.     this.x = x;
  12. }
  14. public int getY() {
  15.     return y;
  16. }
  18. public void setY(int y) {
  19.     this.y = y;
  20. }

}

  2. 2. **我方坦克类**
  3. ```java
  4. package com.hsp.tank01.tankgame;
  6. public class Hero extends Tank{
  8.     public Hero(int x, int y) {
  9.         super(x, y);
  10.     }
  11. }
  1. 画板 - 绘制坦克 ```java package com.hsp.tank01.tankgame;

import javax.swing.; import java.awt.;

public class MyPanel extends JPanel { //定义我的坦克 Hero hero = null;

  1. public MyPanel() {
  2.     hero = new Hero(100, 100);  //初始化自己的坦克
  3. }
  5. @Override
  6. public void paint(Graphics g) {
  7.     super.paint(g);
  8.     g.fillRect(0, 0, 1000, 750);  //填充矩形，默认是黑色
  10.     //画出坦克-封装到方法
  11.     drawTank(hero.getX(), hero.getY(), g, 0, 0);
  12.     drawTank(hero.getX(), hero.getY() + 100, g, 0, 1);
  13.     drawTank(hero.getX() + 50, hero.getY() + 100, g, 0, 1);
  14.     drawTank(hero.getX() + 100, hero.getY() + 100, g, 0, 1);
  15. }
  16. //编写方法，画出坦克
  18. /**
  19.  * @param x      坦克的左上角x坐标
  20.  * @param y      坦克的左上角y坐标
  21.  * @param g      画笔
  22.  * @param direct 坦克的方向(上下左右)
  23.  * @param type   坦克类型
  24.  */
  25. public void drawTank(int x, int y, Graphics g, int direct, int type) {
  26.     //根据不同类型的坦克，设置不同的颜色
  27.     switch (type) {
  28.         case 0:  //我方坦克
  29.             g.setColor(Color.cyan);
  30.             break;
  31.         case 1:  //敌方坦克
  32.             g.setColor(Color.yellow);
  33.             break;
  34.     }
  35.     //根据坦克的方向，来绘制坦克
  36.     switch (direct) {
  37.         case 0: //向上
  38.             g.fill3DRect(x, y, 10, 60, false);
  39.             g.fill3DRect(x + 30, y, 10, 60, false);
  40.             g.fill3DRect(x + 10, y + 10, 20, 40, false);
  41.             g.fillOval(x + 10, y + 20, 20, 20);
  42.             g.drawLine(x + 20, y, x + 20, y + 20);
  43.             break;
  44.         default:
  45.             System.out.println("暂时没处理");
  46.             break;
  47.     }
  48. }

}

  2. 4. **游戏运行窗口**
  3. ```java
  4. package com.hsp.tank01.tankgame;
  6. import javax.swing.*;
  8. public class HspTankGame01 extends JFrame {
  9.     MyPanel mp = null;
  11.     public static void main(String[] args) {
  12.         HspTankGame01 game01 = new HspTankGame01();
  13.     }
  14.     public HspTankGame01() {
  15.         mp = new MyPanel();
  16.         this.add(mp);
  17.         this.setSize(1000,750);
  18.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  19.         this.setVisible(true);
  20.     }
  21. }

四、Java事件处理机制

4.1 快速上手 - 让小球动起来

  1. package com.hsp.event_;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.KeyEvent;
  6. import java.awt.event.KeyListener;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  * 演示小球通过键盘控制上下左右的移动 -> 讲解Java的事件控制
  12.  */
  13. public class BallMove extends JFrame{
  14.     MyPanel mp = null;
  15.     public static void main(String[] args) {
  16.         new BallMove();
  17.     }
  18.     public BallMove() {
  19.         mp = new MyPanel();
  20.         this.add(mp);
  21.         this.setSize(400,300);
  22.         //窗口JFrame 对象可以监听键盘事件，即可以监听到面板上发生的键盘事件
  23.         this.addKeyListener(mp); //MyPanel实现了KeyListener，所以mp实例可以作为参数传入
  24.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  25.         this.setVisible(true);
  27.     }
  28. }
  30. //画板，可以画出小球
  31. //KeyListener 是一个监听器，可以监听键盘事件
  32. class MyPanel extends JPanel implements KeyListener {
  33.     //为了让小球可以移动，我们把它的左上角的坐标设置成变量
  34.     int x = 10;
  35.     int y = 10;
  37.     @Override
  38.     public void paint(Graphics g) {
  39.         super.paint(g);
  40.         g.fillOval(x,y,20,20);  // 绘制小球
  41.     }
  43.     //有字符输出时，该方法就会监听到
  44.     @Override
  45.     public void keyTyped(KeyEvent e) {
  46.     }
  48.     //当某个键按下时，该方法就会被触发
  49.     @Override
  50.     public void keyPressed(KeyEvent e) {
  51.         //System.out.println((char)e.getKeyCode() + "被按下");
  53.         //根据用户按下的不同键，来处理小球的移动（上下左右的键）
  54.         if (e.getKeyCode() == KeyEvent.VK_DOWN) {
  55.             y++;  //小球向下移动
  56.         } else if (e.getKeyCode() == KeyEvent.VK_UP) {
  57.             y--;  //小球向上移动
  58.         } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
  59.             x--;  //小球向左移动
  60.         } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
  61.             x++;  //小球向右移动
  62.         }
  64.         //让面板重绘
  65.         this.repaint();
  66.     }
  68.     //当某个键松开时，该方法就会被触发
  69.     @Override
  70.     public void keyReleased(KeyEvent e) {
  71.     }
  72. }

4.2 基本说明

Java事件处理是采取“委派事件模型”。当事件发生时，产生事件的对象，会把此“信息”传递给“事件的监听者”处理，这里所说的“信息”实际上就是 java.awt.event 事件类库里某个类创建的对象，把它称为“事件的对象”。

4.3 示意图

坦克大战【1】 - 图4

4.4 机制分析

image.png

4.5 事件处理机制深入理解

  1. 事件源：事件源是一个产生事件的对象，比如按钮，窗口等
  2. 事件：事件就是承载事件源状态改变时的对象，比如键盘事件、鼠标事件、窗口事件等等，会生成一个事件对象，该对象保存着当前事件很多信息，比如 KeyEvent 对象含有被按下键的 Code值。java.awt.event包 和 javax.swing.event包 中定义了各种事件类型

  3. 事件类型：查阅jdk文档 | 事件类 | 说明 | | —- | —- | | ActionEvent | 通常在按下按钮，或双击一个列表项或选中某个菜单时发生 | | AdjustmentEvent | 当操作一个滚动条时发生 | | ComponentEvent | 当一个组件隐藏，移动，改变大小时发生 | | ContainerEvent | 当一个组件从容器中加入或者删除时发生 | | FocusEvent | 当一个组件获得或者失去焦点时发生 | | ItemEvent | 当一个复选框或者列表项被选中时，当一个选择框或选择菜单被选中 | | KeyEvent | 当键盘的按键被按下、松开时发生 | | MouseEvent | 当鼠标被拖动，移动，点击，按下，松开… 时发生 | | TextEvent | 当文本框和文本域的文本发生改变时发生 | | WindowEvent | 当一个窗口激活，关闭，失效，恢复，最小化… 时发生 |

  4. 事件监听器接口：

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

image.png

五、坦克大战游戏 (1.0版)

5.1 让坦克动起来

通过上面学习的Java事件处理机制和Java绘图技术，来实现让我们的坦克可以通过按键控制上下左右(wsad表示)的移动。

5.2 坦克类

  1. package com.hsp.tank01.tankgame02;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class Tank {
  8.     private int x;  //坦克的横坐标
  9.     private int y;  //坦克的纵坐标
  10.     private int direct;  //坦克方向  0:向上  1:向右  2:向下  3:向左
  11.     private int type;  //坦克类型  0:我方坦克  1:敌方坦克
  12.     private int speed = 1;  //坦克速度
  14.     public Tank(int x, int y) {
  15.         this.x = x;
  16.         this.y = y;
  17.     }
  19.     public Tank(int x, int y, int direct, int type) {
  20.         this.x = x;
  21.         this.y = y;
  22.         this.direct = direct;
  23.         this.type = type;
  24.     }
  27.     //上右下左移动方法
  28.     public void moveUp() {
  29.         y -= speed;
  30.     }
  31.     public void moveRight() {
  32.         x += speed;
  33.     }
  34.     public void moveDown() {
  35.         y += speed;
  36.     }
  37.     public void moveLeft() {
  38.         x -= speed;
  39.     }
  41.     public int getX() {
  42.         return x;
  43.     }
  45.     public void setX(int x) {
  46.         this.x = x;
  47.     }
  49.     public int getY() {
  50.         return y;
  51.     }
  53.     public void setY(int y) {
  54.         this.y = y;
  55.     }
  57.     public int getDirect() {
  58.         return direct;
  59.     }
  61.     public void setDirect(int direct) {
  62.         this.direct = direct;
  63.     }
  65.     public int getType() {
  66.         return type;
  67.     }
  69.     public void setType(int type) {
  70.         this.type = type;
  71.     }
  73.     public int getSpeed() {
  74.         return speed;
  75.     }
  77.     public void setSpeed(int speed) {
  78.         this.speed = speed;
  79.     }
  80. }

5.3 MyPanel 类

  1. package com.hsp.tank01.tankgame02;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.KeyEvent;
  6. import java.awt.event.KeyListener;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. public class MyPanel extends JPanel implements KeyListener {
  13.     //定义我的坦克
  14.     Hero hero = null;
  15.     public MyPanel() {
  16.         hero = new Hero(300, 300);  //初始化自己的坦克
  17.         hero.setSpeed(3);
  18.     }
  20.     @Override
  21.     public void paint(Graphics g) {
  22.         super.paint(g);
  23.         g.fillRect(0, 0, 1000, 750);  //填充矩形，默认是黑色
  25.         //画出坦克-封装到方法
  26.         drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), hero.getType());
  27.     }
  29.     /**
  30.      * @param x      坦克的左上角x坐标
  31.      * @param y      坦克的左上角y坐标
  32.      * @param g      画笔
  33.      * @param direct 坦克的方向(上下左右)
  34.      * @param type   坦克类型
  35.      */
  36.     public void drawTank(int x, int y, Graphics g, int direct, int type) {
  37.         //根据不同类型的坦克，设置不同的颜色
  38.         switch (type) {
  39.             case 0:  //我方坦克
  40.                 g.setColor(Color.cyan);
  41.                 break;
  42.             case 1:  //敌方坦克
  43.                 g.setColor(Color.yellow);
  44.                 break;
  45.         }
  46.         //根据坦克的方向，来绘制对应的坦克
  47.         //direct表示方向(0:向上  1:向右  2:向下  3:向左)
  48.         switch (direct) {
  49.             case 0: //表示向上
  50.                 g.fill3DRect(x, y, 10, 60, false);
  51.                 g.fill3DRect(x + 30, y, 10, 60, false);
  52.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);
  53.                 g.fillOval(x + 10, y + 20, 20, 20);
  54.                 g.drawLine(x + 20, y, x + 20, y + 20);
  55.                 break;
  56.             case 1:  //表示向右
  57.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);
  58.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);
  59.                 g.fill3DRect(x, y + 20, 40, 20, false);
  60.                 g.fillOval(x + 10, y + 20, 20, 20);
  61.                 g.drawLine(x + 50, y + 30, x + 20, y + 30);
  62.                 break;
  63.             case 2: //表示向下
  64.                 g.fill3DRect(x, y, 10, 60, false);
  65.                 g.fill3DRect(x + 30, y, 10, 60, false);
  66.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);
  67.                 g.fillOval(x + 10, y + 20, 20, 20);
  68.                 g.drawLine(x + 20, y + 60, x + 20, y + 20);
  69.                 break;
  70.             case 3:
  71.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);
  72.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);
  73.                 g.fill3DRect(x, y + 20, 40, 20, false);
  74.                 g.fillOval(x + 10, y + 20, 20, 20);
  75.                 g.drawLine(x - 10, y + 30, x + 20, y + 30);
  76.                 break;
  77.         }
  78.     }
  80.     @Override
  81.     public void keyTyped(KeyEvent e) {
  82.     }
  84.     @Override
  85.     public void keyPressed(KeyEvent e) {
  86.         if (e.getKeyCode() == KeyEvent.VK_W) {
  87.             hero.moveUp();
  88.             hero.setDirect(0);
  89.         } else if (e.getKeyCode() == KeyEvent.VK_D) {
  90.             hero.moveRight();
  91.             hero.setDirect(1);
  92.         } else if (e.getKeyCode() == KeyEvent.VK_S) {
  93.             hero.moveDown();
  94.             hero.setDirect(2);
  95.         } else if (e.getKeyCode() == KeyEvent.VK_A) {
  96.             hero.moveLeft();
  97.             hero.setDirect(3);
  98.         }
  99.         this.repaint();
  100.     }
  102.     @Override
  103.     public void keyReleased(KeyEvent e) {
  104.     }
  105. }

5.4 游戏运行窗口

  1. package com.hsp.tank01.tankgame02;
  3. import javax.swing.*;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class TankGame01 extends JFrame {
  10.     MyPanel mp = null;
  12.     public static void main(String[] args) {
  13.         TankGame01 game01 = new TankGame01();
  14.     }
  15.     public TankGame01() {
  16.         mp = new MyPanel();
  17.         this.add(mp);
  18.         this.setSize(1000,750);
  19.         this.addKeyListener(mp);  //监听
  20.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  21.         this.setVisible(true);
  22.     }
  23. }

六、本章作业

在上面的基础上添加敌方坦克类，并将创建的敌方坦克实例放入到集合中【需考虑线程安全】，然后在面板中调用显示三辆敌方坦克。

敌方坦克类

  1. package com.hsp.tank01.tankgame02;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class Enemy extends Tank{
  8.     public Enemy(int x, int y) {
  9.         super(x, y);
  10.     }
  12.     public Enemy(int x, int y, int direct, int type) {
  13.         super(x, y, direct, type);
  14.     }
  15. }

MyPanel类

  1. package com.hsp.tank01.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.Vector;
  9. /**
  10.  * @author HarborGao
  11.  * @version 1.0
  12.  */
  13. public class MyPanel extends JPanel implements KeyListener {
  14.     //定义我的坦克
  15.     Hero hero = null;
  16.     //定义敌人坦克，放入到 Vector
  17.     Vector<Enemy> enemies = new Vector<>();
  18.     int enemyTankSize = 3;
  19.     public MyPanel() {
  20.         hero = new Hero(200, 150);  //初始化自己的坦克
  21.         hero.setSpeed(3);
  22.         //初始化敌人坦克
  23.         for (int i = 1; i <= enemyTankSize; i++) {
  24.             enemies.add(new Enemy(100*i,10, 2,1));
  25.         }
  26.     }
  28.     @Override
  29.     public void paint(Graphics g) {
  30.         super.paint(g);
  31.         g.fillRect(0, 0, 1000, 750);  //填充矩形，默认是黑色
  33.         //画出坦克-封装到方法
  34.         drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), hero.getType());
  35.         //画出敌人的坦克
  36.         for (Enemy o : enemies) {
  37.             drawTank(o.getX(),o.getY(),g,o.getDirect(),o.getType());
  38.         }
  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) {
  50.         //根据不同类型的坦克，设置不同的颜色
  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.         //direct表示方向(0:向上  1:向右  2:向下  3:向左)
  61.         switch (direct) {
  62.             case 0: //表示向上
  63.                 g.fill3DRect(x, y, 10, 60, false);
  64.                 g.fill3DRect(x + 30, y, 10, 60, false);
  65.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);
  66.                 g.fillOval(x + 10, y + 20, 20, 20);
  67.                 g.drawLine(x + 20, y, x + 20, y + 20);
  68.                 break;
  69.             case 1:  //表示向右
  70.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);
  71.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);
  72.                 g.fill3DRect(x, y + 20, 40, 20, false);
  73.                 g.fillOval(x + 10, y + 20, 20, 20);
  74.                 g.drawLine(x + 50, y + 30, x + 20, y + 30);
  75.                 break;
  76.             case 2: //表示向下
  77.                 g.fill3DRect(x, y, 10, 60, false);
  78.                 g.fill3DRect(x + 30, y, 10, 60, false);
  79.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);
  80.                 g.fillOval(x + 10, y + 20, 20, 20);
  81.                 g.drawLine(x + 20, y + 60, x + 20, y + 20);
  82.                 break;
  83.             case 3:
  84.                 g.fill3DRect(x - 10, y + 10, 60, 10, false);
  85.                 g.fill3DRect(x - 10, y + 40, 60, 10, false);
  86.                 g.fill3DRect(x, y + 20, 40, 20, false);
  87.                 g.fillOval(x + 10, y + 20, 20, 20);
  88.                 g.drawLine(x - 10, y + 30, x + 20, y + 30);
  89.                 break;
  90.         }
  91.     }
  93.     @Override
  94.     public void keyTyped(KeyEvent e) {
  95.     }
  97.     @Override
  98.     public void keyPressed(KeyEvent e) {
  99.         if (e.getKeyCode() == KeyEvent.VK_W) {
  100.             hero.moveUp();
  101.             hero.setDirect(0);
  102.         } else if (e.getKeyCode() == KeyEvent.VK_D) {
  103.             hero.moveRight();
  104.             hero.setDirect(1);
  105.         } else if (e.getKeyCode() == KeyEvent.VK_S) {
  106.             hero.moveDown();
  107.             hero.setDirect(2);
  108.         } else if (e.getKeyCode() == KeyEvent.VK_A) {
  109.             hero.moveLeft();
  110.             hero.setDirect(3);
  111.         }
  112.         this.repaint();
  113.     }
  115.     @Override
  116.     public void keyReleased(KeyEvent e) {
  117.     }
  118. }

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java