• 绘图（二）五子棋小游戏

    AWT编程 · 语雀

    仓库：Java图形化界面: Java图形化界面学习demo与资料 (gitee.com)

    处理位图

    如果仅仅绘制一些简单的几何图形，程序的图形效果依然比较单调 。 AWT 也允许在组件上绘制位图， Graphics 提供了 drawlmage() 方法用于绘制位图，该方法需要一个Image参数一一代表位图，通过该方法就可 以绘制出指定的位图 。

    位图使用步骤：

    1.创建Image的子类对象BufferedImage(int width,int height,int ImageType),创建时需要指定位图的宽高及类型属性；此时相当于在内存中生成了一张图片；

    2.调用BufferedImage对象的getGraphics()方法获取画笔，此时就可以往内存中的这张图片上绘图了，绘图的方法和之前学习的一模一样；

    3.调用组件的drawImage()方法，一次性的内存中的图片BufferedImage绘制到特定的组件上。

    使用位图绘制组件的好处：

    使用位图来绘制组件，相当于实现了图的缓冲区，此时绘图时没有直接把图形绘制到组件上，而是先绘制到内存中的BufferedImage上，等全部绘制完毕，再一次性的图像显示到组件上即可，这样用户的体验会好一些。

    案例：

    通过BufferedImage实现一个简单的手绘程序：通过鼠标可以在窗口中画图。

    演示代码：

    1. package awt_swimg.day04;
    2.  
    3. import awt_swimg.day01.Utils;
    4.  
    5. import javax.swing.*;
    6. import java.awt.*;
    7. import java.awt.event.*;
    8. import java.awt.image.BufferedImage;
    9.  
    10. public class HandDraw {
    11.  
    12.     //定义画图区的宽高
    13.     private final int AREA_WIDTH = 500;
    14.     private final int AREA_HEIGHT = 400;
    15.  
    16.     //定义变量，保存上一次鼠标拖动时，鼠标的坐标
    17.     private int preX = -1;
    18.     private int preY = -1;
    19.     //定义一个右键菜单，用于设置画笔的颜色
    20.     private PopupMenu popupMenu=new PopupMenu();
    21.     private MenuItem redItem = new MenuItem("红色");
    22.     private MenuItem greenItem = new MenuItem("绿色");
    23.     private MenuItem buleItem = new MenuItem("蓝色");
    24.     //定义一个BufferedImage对象
    25.     private BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT, BufferedImage.TYPE_INT_RGB);
    26.     //获取BufferedImage对象关联的画笔
    27.     private Graphics g=image.getGraphics();
    28.     //定义窗口对象
    29.     private JFrame frame = new JFrame("简单手绘程序");
    30.     //定义画布对象
    31.     private Canvas canvas=new Canvas(){
    32.         @Override
    33.         public void paint(Graphics g) {
    34.             g.drawImage(image,0,0,null);
    35.         }
    36.     };
    37.     //定义一个Color对象，用来保存用户设置的画笔颜色,默认为黑色
    38.     private Color color = Color.BLACK;
    39.     public void init(){
    40.  
    41.         redItem.addActionListener(e -> color = Color.red);
    42.         greenItem.addActionListener(e -> color = Color.GREEN);
    43.         buleItem.addActionListener(e -> color = Color.BLUE);
    44.         canvas.addMouseListener(new MouseAdapter() {
    45.             @Override
    46.             public void mouseReleased(MouseEvent e) {
    47.                 if (e.isPopupTrigger()) {
    48.                     popupMenu.show(canvas, e.getX(), e.getY());
    49.                 }
    50.                 preX = -1;
    51.                 preY = -1;
    52.             }
    53.         });
    54.         canvas.addMouseMotionListener(new MouseMotionAdapter() {
    55.             @Override
    56.             public void mouseDragged(MouseEvent e) {
    57.                 if (preX > 0 && preY > 0) {
    58.                     g.setColor(color);
    59.                     g.drawLine(preX, preY, e.getX(), e.getY());
    60.                 }
    61.                 preX = e.getX();
    62.                 preY = e.getY();
    63.                 canvas.repaint();
    64.             }
    65.         });
    66.         g.fillRect(0,0,AREA_WIDTH,AREA_HEIGHT);
    67.         canvas.setPreferredSize(new Dimension(AREA_WIDTH,AREA_HEIGHT));
    68.         canvas.add(popupMenu);
    69.         popupMenu.add(redItem);
    70.         popupMenu.add(greenItem);
    71.         popupMenu.add(buleItem);
    72.  
    73.         frame.add(canvas);
    74.         Utils.setJFrame(frame);
    75.     }
    76.  
    77.     public static void main(String[] args) {
    78.         new HandDraw().init();
    79.     }
    80.  
    81.  
    82.  
    83. }

    ImageIO的使用

    在实际生活中，很多软件都支持打开本地磁盘已经存在的图片，然后进行编辑，编辑完毕后，再重新保存到本地磁盘。如果使用AWT要完成这样的功能，那么需要使用到ImageIO这个类，可以操作本地磁盘的图片文件。

    方法名称

    方法功能

    static BufferedImage read(File input)

    读取本地磁盘图片文件

    static BufferedImage read(InputStream input)

    读取本地磁盘图片文件

    static boolean write(RenderedImage im, String formatName, File output)

    往本地磁盘中输出图片文件

    案例：

    编写图片查看程序,支持另存操作

    演示代码：

    1. import javax.imageio.ImageIO;
    2. import java.awt.image.BufferedImage;
    3. import java.io.File;
    4.  
    5. public class ReadAndSaveImage {
    6.  
    7.     private Frame frame = new Frame("图片查看器");
    8.  
    9.     private BufferedImage image;
    10.  
    11.     private class MyCanvas  extends Canvas{
    12.  
    13.         @Override
    14.         public void paint(Graphics g) {
    15.             if (image!=null){
    16.                 g.drawImage(image,0,0,image.getWidth(),image.getHeight(),null);
    17.             }
    18.         }
    19.     }
    20.  
    21.     private MyCanvas imageComponent = new MyCanvas();
    22.  
    23.     public void init() throws Exception{
    24.  
    25.         //设置菜单项
    26.         MenuBar mb = new MenuBar();
    27.         Menu menu = new Menu("文件");
    28.         MenuItem openItem = new MenuItem("打开");
    29.         MenuItem saveItem = new MenuItem("另存为");
    30.  
    31.         openItem.addActionListener(e -> {
    32.             //弹出对话框，选择本地图片
    33.             FileDialog oDialog = new FileDialog(frame);
    34.             oDialog.setVisible(true);
    35.             //读取用户选择的图片
    36.             String dir = oDialog.getDirectory();
    37.             String file = oDialog.getFile();
    38.             try {
    39.                 image = ImageIO.read(new File(dir,file));
    40.  
    41.                 imageComponent.repaint();
    42.  
    43.             } catch (IOException e1) {
    44.                 e1.printStackTrace();
    45.             }
    46.  
    47.         });
    48.  
    49.  
    50.         saveItem.addActionListener(e -> {
    51.             //弹出对话框，另存为
    52.             FileDialog sDialog = new FileDialog(frame,"保存图片",FileDialog.SAVE);
    53.             sDialog.setVisible(true);
    54.             String dir = sDialog.getDirectory();
    55.             String file = sDialog.getFile();
    56.  
    57.             try {
    58.                 ImageIO.write(image,"JPEG",new File(dir,file));
    59.             } catch (IOException e1) {
    60.                 e1.printStackTrace();
    61.             }
    62.         });
    63.  
    64.         mb.add(menu);
    65.         menu.add(openItem);
    66.         menu.add(saveItem);
    67.  
    68.         frame.setMenuBar(mb);
    69.         frame.add(imageComponent);
    70.  
    71.         frame.setBounds(200,200,800,600);
    72.  
    73.         frame.setVisible(true);
    74.  
    75.         frame.addWindowListener(new WindowAdapter() {
    76.             @Override
    77.             public void windowClosing(WindowEvent e) {
    78.                 System.exit(0);
    79.             }
    80.         });
    81.     }
    82.  
    83.  
    84.  
    85.     public static void main(String[] args) throws Exception {
    86.         new ReadAndSaveImage().init();
    87.     }
    88. }

    五子棋

    接下来，我们使用之前学习的绘图技术，做一个五子棋的游戏。

    演示代码：

    1. package awt_swimg.day04;
    2.  
    3. import awt_swimg.day01.Utils;
    4.  
    5. import javax.imageio.ImageIO;
    6. import javax.swing.*;
    7. import java.awt.*;
    8. import java.awt.event.*;
    9. import java.awt.image.BufferedImage;
    10. import java.io.File;
    11. import java.io.IOException;
    12.  
    13. public class Gobang {
    14.     //定义三个BufferedImage，分别代表棋盘图、黑子图、白子图
    15.     private BufferedImage table;
    16.     private BufferedImage black;
    17.     private BufferedImage white;
    18.  
    19.     //定义一个BufferedImage，代表当鼠标移动时将要下子的选择框
    20.     private BufferedImage selected;
    21.  
    22.     //定义棋盘的宽高，这里的定义尺寸和给定的board.jpg图片的尺寸一致因为棋盘背景是通过图片加载的
    23.     private final int TABLE_WIDTH = 535;
    24.     private final int TABLE_HEIGHT = 536;
    25.  
    26.     //定义棋盘中，每行和每列可下子的数目，这个数目跟给定的board.jpg中的数目是一致的，都为15
    27.     private final int BOARD_SIZE = 15;
    28.  
    29.     //定义每个棋子所占棋盘总宽度的大小比率；每个棋子所占宽度 535/15=35
    30.     private final int RATE = TABLE_WIDTH / BOARD_SIZE;
    31.  
    32.     //定义棋盘有效区域与背景图坐标之间的偏移值，x坐标右移5个像素，y坐标下移6个像素
    33.     private final int X_OFFSET = 5;
    34.     private final int Y_OFFSET = 6;
    35.     /*
    37.       定义一个二维数组充当棋盘上每个位置处的棋子；
    38.       该数组的索引与该棋子在棋盘上的坐标需要有一个对应关系：
    39.           例如： 索引[2][3]处的棋子，对一个的真实绘制坐标应该是：
    41.               xpos = 2*RATE+X_OFFSET=75;
    42.               ypos = 3*RATE+Y_OFFSET=111;
    44.    */
    45.     private int[][] board = new int[BOARD_SIZE][BOARD_SIZE];//如果存储0，代表没有棋子，如果存储1，代表黑棋，如果存储2，代表白棋
    46.  
    47.     //定义五子棋游戏窗口
    48.     private JFrame frame = new JFrame("五子棋游戏");
    49.  
    50.     //定义变量，记录当前选中的坐标点对应的boad数组中对应的棋子索引；
    51.     private int selectX = -1;
    52.     private int selectY = -1;
    53.  
    54.     //定义一个变量，记录当前用户选择下的是白棋还是黑棋还是清除，清除：0，黑棋：1，白棋：2；
    55.     private int chessCategory = 1;
    56.  
    57.     private JPanel canvas = new JPanel() {
    58.         @Override
    59.         public void paint(Graphics g) {
    60.             g.drawImage(table, 0, 0, null);
    61.             if (selectX > 0 && selectY > 0) {
    62.                 g.drawImage(selected, selectX * RATE + X_OFFSET, selectY * RATE + Y_OFFSET, null);
    63.             }
    64.             for (int i = 0; i < BOARD_SIZE; i++) {
    65.                 for (int j = 0; j < BOARD_SIZE; j++) {
    66.                     if (board[i][j] == 2) {
    67.                         g.drawImage(white, i * RATE + X_OFFSET, j * RATE + Y_OFFSET, null);
    68.                     }
    69.                     if (board[i][j] == 1) {
    70.                         g.drawImage(black, i * RATE + X_OFFSET, j * RATE + Y_OFFSET, null);
    71.                     }
    72.                 }
    73.             }
    74.         }
    75.     };
    76.     private Panel panel = new Panel();
    77.     private Button whiteChess = new Button("白棋");
    78.     private Button blackChess = new Button("黑棋");
    79.     private Button delete = new Button("删除");
    80.  
    81.  
    82.     public void init() throws IOException {
    83.         //初始化数组，默认
    84.         for (int i = 0; i < BOARD_SIZE; i++) {
    85.             for (int j = 0; j < BOARD_SIZE; j++) {
    86.                 board[i][j] = 0;
    87.             }
    88.         }
    89.         canvas.addMouseMotionListener(new MouseMotionAdapter() {
    90.             @Override
    91.             public void mouseMoved(MouseEvent e) {
    92.                 selectX = (e.getX() - X_OFFSET) / RATE;
    93.                 selectY = (e.getY() - Y_OFFSET) / RATE;
    94.                 canvas.repaint();
    95.             }
    96.  
    97.         });
    98.         canvas.addMouseListener(new MouseAdapter() {
    99.  
    100.             @Override
    101.             public void mouseClicked(MouseEvent e) {
    102.                 int xChess = (e.getX() - X_OFFSET) / RATE;
    103.                 int yChess = (e.getY() - Y_OFFSET) / RATE;
    104.                 board[xChess][yChess] = chessCategory;
    105.                 canvas.repaint();
    106.             }
    107.  
    108.             @Override
    109.             public void mouseExited(MouseEvent e) {
    110.                 selectX = -1;
    111.                 selectY = -1;
    112.                 canvas.repaint();
    113.             }
    114.         });
    115.         whiteChess.addActionListener(e -> {
    116.             chessCategory = 2;
    117.             this.setButtonColor(Color.green,Color.white,Color.white);
    118.         });
    119.         blackChess.addActionListener(e -> {
    120.             chessCategory = 1;
    121.             this.setButtonColor(Color.white,Color.green,Color.white);
    122.         });
    123.         delete.addActionListener(e -> {
    124.             chessCategory = 0;
    125.             this.setButtonColor(Color.white,Color.white,Color.green);
    126.         });
    127.  
    128.  
    129.         table = ImageIO.read(new File("src/awt_swimg/img/board.jpg"));
    130.         white = ImageIO.read(new File("src/awt_swimg/img/white.gif"));
    131.         black = ImageIO.read(new File("src/awt_swimg/img/black.gif"));
    132.         selected = ImageIO.read(new File("src/awt_swimg/img/selected.gif"));
    133.         canvas.setPreferredSize(new Dimension(table.getWidth(), table.getHeight()));
    134.  
    135.  
    136.         panel.add(whiteChess);
    137.         panel.add(blackChess);
    138.         panel.add(delete);
    139.         frame.add(canvas);
    140.         frame.add(panel, BorderLayout.SOUTH);
    141.         Utils.setJFrame(frame);
    142.  
    143.  
    144.     }
    145.  
    146.     public void setButtonColor(Color w,Color b ,Color d){
    147.         whiteChess.setBackground(w);
    148.         blackChess.setBackground(b);
    149.         delete.setBackground(d);
    150.     }
    151.  
    152.     public static void main(String[] args) throws IOException {
    153.         new Gobang().init();
    154.     }
    155. }

  • 相关阅读:
    uniapp和vue3+ts创建自定义下拉选择框组件
    LeetCode简单题之解密消息
    uniapp 首页制作
    SpringCloud集成链路追踪Sleuth+Zipkin
    神经网络在飞行疲劳检测中的应用综述
    敏捷交付的工程效能治理
    LeetCode【69. x 的平方根】
    vsCode 配置 用户代码
    Python杀死Excel？众多模块哪家强
    自助式数据分析平台：JVS智能BI功能介绍（二）数据集管理
  • 原文地址：https://blog.csdn.net/m0_73843666/article/details/132868532