1. 博客有时间就写写，所以一篇可能会拆成很多篇，写完后计划再合在一起。
  2. 首先肯定是要实现连连看的界面。
    1. 先准备连连看要的图片。、
    2. “LianLianKan”就是项目名称。
    4. 当然，如果小白看我的博客想学到什么，我会说还是放弃，因为文字描述会忽视很多细节，而细节决定bug……
    5. 所以，包括以前的和以后的，博文都会是给自己看看或者内行触类旁通的，也就是——笔记。
    6. 我也是今天才明白博文的真正意义吧，所以以后的博文风格会大改……尽量会用自己语言风格来描述以便自己能看懂。
  3. 废话少说，现在的第2步：
    1. 创建数组，一个持久化存储的容器:存储连连看的图片 迷宫寻路
    2. 2.有图像在数组看得到，先秀一下看看，免得一开始代码就错了，后面还写个毛。
    3. 到这一步，主函数基本没什么变化。TableFrame.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.awt.FlowLayout;
      4.  
      5.  import javax.swing.JFrame;
      6.  import javax.swing.JTable;
      7.  
      8.  /**
      9.   *
      10.   * @author Administrator
      11.   *
      12.   */
      13.  @SuppressWarnings("serial")
      14.  public class TableFrame extends JFrame{
      15.      public static void main(String[] args) {
      16.          new TableFrame().initFrame();
      17.      }
      18.  
      19.      private void initFrame() {
      20.          this.setSize(800,600);
      21.          this.setDefaultCloseOperation(3);
      22.          this.setLayout(new FlowLayout());
      23.          //设置窗体不能改变大小
      24.          this.setResizable(false);
      25.          this.setLocationRelativeTo(null);
      26.  
      27.          MyTableModel mtm = new MyTableModel();
      28.          JTable table = new JTable(mtm);
      29.          this.add(table);
      30.          this.setVisible(true);
      31.  
      32.      }
      33.  }
    4. 说明在代码里面写清楚了 。 
      1.  package com.edp.impl;
      2.  
      3.  import java.util.Random;
      4.  
      5.  import javax.swing.event.TableModelListener;
      6.  import javax.swing.table.TableModel;
      7.  
      8.  public class MyTableModel implements TableModel {
      9.      //1.创建数组，一个持久化存储的容器:存储连连看的图片 迷宫寻路
      10.      private String[][] saveDB = new String[13][13];
      11.      //2.有图像在数组看得到
      12.      //2_2在存的时候想到图片最好随机
      13.      private Random ran = new Random();//创建随机对象
      14.      //2_1 把图片存到数组
      15.      public MyTableModel() {
      16.          int value;
      17.          for(int i = 0;i<saveDB.length;i++){
      18.              for (int j = 0; j < saveDB[i].length; j++) {
      19.                  value = ran.nextInt(13)+1;
      20.                  saveDB[i][j] = "image/lianliankanimage/"+value+".jpg";
      21.              }
      22.          }
      23.      }
      24.  
      25.      //获取列类型
      26.      public Class<?> getColumnClass(int columnIndex) {
      27.          return String.class;
      28.      }
      29.      //获取总行数
      30.      public int getRowCount() {
      31.          return saveDB.length;
      32.      }
      33.      //获取总列数
      34.      public int getColumnCount() {
      35.          return saveDB[0].length;
      36.      }
      37.      //获取表格列名
      38.      public String getColumnName(int columnIndex) {
      39.          //连连看游戏没必要出现表格列名呀，反正不需要
      40.          //实现列名可以通过switch语句，最适合实现。然后在TableFrame类里面实现
      41.          //不过想要实现得这样(用到JScrollPane)：
      42.          //    JTable table = new JTable(mtm);
      43.          //    //把JTable对象加载到JScrollPane
      44.          //      JScrollPane jsp = new JScrollPane(table);
      45.          //    this.add(jsp);
      46.          //JScrollPane到底是个什么玩意，请自己去查java API说明书。
      47.          return null;
      48.      }
      49.      //设置单元格数据
      50.      public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
      51.      }
      52.      //获得单元格数据
      53.      public Object getValueAt(int rowIndex, int columnIndex) {
      54.          return 0;
      55.      }
      56.      //单元格是否编辑
      57.      public boolean isCellEditable(int rowIndex, int columnIndex) {
      58.          //连连看游戏肯定不需要对单元格进行修改或删除，游戏逻辑自会处理相关格子内的东西。
      59.          return false;
      60.      }
      61.      public void removeTableModelListener(TableModelListener l) {}
      62.      public void addTableModelListener(TableModelListener l) {}
      63.  }
    5. 运行结果是这样子的
    7. 然后开始插入图片看看。
    8. TableFrame.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.awt.FlowLayout;
      4.  
      5.  import javax.swing.JFrame;
      6.  import javax.swing.JTable;
      7.  import javax.swing.table.TableColumnModel;
      8.  
      9.  /**
      10.   *
      11.   * @author Administrator
      12.   *
      13.   */
      14.  @SuppressWarnings("serial")
      15.  public class TableFrame extends JFrame{
      16.      public static void main(String[] args) {
      17.          new TableFrame().initFrame();
      18.      }
      19.  
      20.      private void initFrame() {
      21.          this.setSize(800,600);
      22.          this.setDefaultCloseOperation(3);
      23.          this.setLayout(new FlowLayout());
      24.          //设置窗体不能改变大小
      25.          this.setResizable(false);
      26.          this.setLocationRelativeTo(null);
      27.  
      28.          MyTableModel mtm = new MyTableModel();
      29.          JTable table = new JTable(mtm);
      30.          this.add(table);
      31.          //设置显示样式
      32.          //列宽
      33.          table.setRowHeight(35);
      34.          //获取列模型
      35.          TableColumnModel columnModel = table.getColumnModel();
      36.          for (int i = 0; i < columnModel.getColumnCount(); i++) {
      37.              columnModel.getColumn(i).setPreferredWidth(35);
      38.          }
      39.          //设置行列都不能被选中
      40.          table.setRowSelectionAllowed(false);
      41.          table.setColumnSelectionAllowed(false);
      42.          this.setVisible(true);
      43.  
      44.      }
      45.  }
    9. MyTableModel.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.util.Random;
      4.  
      5.  import javax.swing.ImageIcon;
      6.  import javax.swing.event.TableModelListener;
      7.  import javax.swing.table.TableModel;
      8.  
      9.  public class MyTableModel implements TableModel {
      10.      //1.创建数组，一个持久化存储的容器:存储连连看的图片 迷宫寻路
      11.      private String[][] saveDB = new String[13][13];
      12.      //2.有图像在数组看得到
      13.      //2_2在存的时候想到图片最好随机
      14.      private Random ran = new Random();//创建随机对象
      15.      //2_1 把图片存到数组
      16.      public MyTableModel() {
      17.          int value;
      18.          for(int i = 0;i<saveDB.length;i++){
      19.              for (int j = 0; j < saveDB[i].length; j++) {
      20.                  value = ran.nextInt(13)+1;
      21.                  saveDB[i][j] = "image/"+value+".jpg";
      22.              }
      23.          }
      24.      }
      25.  
      26.      //获取列类型
      27.      public Class<?> getColumnClass(int columnIndex) {
      28.          return javax.swing.ImageIcon.class;
      29.      }
      30.      //获取总行数
      31.      public int getRowCount() {
      32.          return saveDB.length;
      33.      }
      34.      //获取总列数
      35.      public int getColumnCount() {
      36.          //这里考虑一个bug：如果连列数都没有，这行代码就会报出异常
      37.          if(saveDB.length>0){
      38.              return saveDB[0].length;
      39.          }
      40.          return 0;
      41.      }
      42.      //获取表格列名
      43.      public String getColumnName(int columnIndex) {
      44.          //连连看游戏没必要出现表格列名呀，反正不需要
      45.          //实现列名可以通过switch语句，最适合实现。然后在TableFrame类里面实现
      46.          //不过想要实现得这样(用到JScrollPane)：
      47.          //    JTable table = new JTable(mtm);
      48.          //    //把JTable对象加载到JScrollPane
      49.          //      JScrollPane jsp = new JScrollPane(table);
      50.          //    this.add(jsp);
      51.          //JScrollPane到底是个什么玩意，请自己去查java API说明书。
      52.          return null;
      53.      }
      54.      //设置单元格数据
      55.      public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
      56.           saveDB[rowIndex][columnIndex] = (String)aValue;
      57.      }
      58.      //获得单元格数据
      59.      public Object getValueAt(int rowIndex, int columnIndex) {
      60.          //返回图片
      61.          ImageIcon icon = new ImageIcon(saveDB[rowIndex][columnIndex]);
      62.          return icon;
      63.  
      64.      }
      65.      //单元格是否编辑
      66.      public boolean isCellEditable(int rowIndex, int columnIndex) {
      67.          //连连看游戏肯定不需要对单元格进行修改或删除，游戏逻辑自会处理相关格子内的东西。
      68.          return false;
      69.      }
      70.      public void removeTableModelListener(TableModelListener e) {}
      71.      public void addTableModelListener(TableModelListener e) {}
      72.  }
    10. 运行后，什么都出来了。
    12. 接下来是实现连连看游戏的消除。
    13. 消除肯定要用鼠标点呀点的。而实现鼠标操作，肯定是要监控。
    14. 监控插哪呢，肯定要是面板创建完，就监控。

    15. 回顾一下处理连连看消除逻辑(算法实现）

      1. 相同图片能够消除

      2. 在同一行或者同一列无障碍物可消除

      3. 一个拐点可消除

      4. 两个拐点可消除

    16. TableFrame.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.awt.FlowLayout;
      4.  
      5.  import javax.swing.JFrame;
      6.  import javax.swing.JTable;
      7.  import javax.swing.table.TableColumnModel;
      8.  
      9.  /**
      10.   *
      11.   * @author Administrator
      12.   *
      13.   */
      14.  @SuppressWarnings("serial")
      15.  public class TableFrame extends JFrame{
      16.      public static void main(String[] args) {
      17.          new TableFrame().initFrame();
      18.      }
      19.  
      20.      private void initFrame() {
      21.          this.setSize(800,600);
      22.          this.setDefaultCloseOperation(3);
      23.          this.setLayout(new FlowLayout());
      24.          //设置窗体不能改变大小
      25.          this.setResizable(false);
      26.          this.setLocationRelativeTo(null);
      27.  
      28.          MyTableModel mtm = new MyTableModel();
      29.          JTable table = new JTable(mtm);
      30.          this.add(table);
      31.          //设置显示样式
      32.          //列宽
      33.          table.setRowHeight(35);
      34.          //获取列模型
      35.          TableColumnModel columnModel = table.getColumnModel();
      36.          for (int i = 0; i < columnModel.getColumnCount(); i++) {
      37.              columnModel.getColumn(i).setPreferredWidth(35);
      38.          }
      39.          //设置行列都不能被选中
      40.          table.setRowSelectionAllowed(false);
      41.          table.setColumnSelectionAllowed(false);
      42.          this.setVisible(true);
      43.  
      44.          //添加监听器
      45.          LLKMouseListener llkListener = new LLKMouseListener(mtm);
      46.          table.addMouseListener(llkListener);
      47.      }
      48.  }
    17. MyTableModel.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.util.Random;
      4.  
      5.  import javax.swing.ImageIcon;
      6.  import javax.swing.event.TableModelListener;
      7.  import javax.swing.table.TableModel;
      8.  
      9.  public class MyTableModel implements TableModel {
      10.      //1.创建数组，一个持久化存储的容器:存储连连看的图片 迷宫寻路
      11.      private String[][] saveDB = new String[13][13];
      12.      //2.有图像在数组看得到
      13.      //2_2在存的时候想到图片最好随机
      14.      private Random ran = new Random();//创建随机对象
      15.      //2_1 把图片存到数组
      16.      //3.消除肯定要用鼠标点呀点的。而实现鼠标操作，肯定是要监控。
      17.      public MyTableModel() {
      18.          int value;
      19.          for(int i = 0;i<saveDB.length;i++){
      20.              for (int j = 0; j < saveDB[i].length; j++) {
      21.                  value = ran.nextInt(13)+1;
      22.                  saveDB[i][j] = "image/"+value+".jpg";
      23.              }
      24.          }
      25.      }
      26.  
      27.      //获取列类型
      28.      public Class<?> getColumnClass(int columnIndex) {
      29.          return javax.swing.ImageIcon.class;
      30.      }
      31.      //获取总行数
      32.      public int getRowCount() {
      33.          return saveDB.length;
      34.      }
      35.      //获取总列数
      36.      public int getColumnCount() {
      37.          //这里考虑一个bug：如果连列数都没有，这行代码就会报出异常
      38.          if(saveDB.length>0){
      39.              return saveDB[0].length;
      40.          }
      41.          return 0;
      42.      }
      43.      //获取表格列名
      44.      public String getColumnName(int columnIndex) {
      45.          //连连看游戏没必要出现表格列名呀，反正不需要
      46.          //实现列名可以通过switch语句，最适合实现。然后在TableFrame类里面实现
      47.          //不过想要实现得这样(用到JScrollPane)：
      48.          //    JTable table = new JTable(mtm);
      49.          //    //把JTable对象加载到JScrollPane
      50.          //      JScrollPane jsp = new JScrollPane(table);
      51.          //    this.add(jsp);
      52.          //JScrollPane到底是个什么玩意，请自己去查java API说明书。
      53.          return null;
      54.      }
      55.      //设置单元格数据
      56.      public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
      57.           saveDB[rowIndex][columnIndex] = (String)aValue;
      58.      }
      59.      //获得单元格数据
      60.      public Object getValueAt(int rowIndex, int columnIndex) {
      61.          //返回图片
      62.          ImageIcon icon = new ImageIcon(saveDB[rowIndex][columnIndex]);
      63.          return icon;
      64.  
      65.      }
      66.      //单元格是否编辑
      67.      public boolean isCellEditable(int rowIndex, int columnIndex) {
      68.          //连连看游戏肯定不需要对单元格进行修改或删除，游戏逻辑自会处理相关格子内的东西。
      69.          return false;
      70.      }
      71.      public void removeTableModelListener(TableModelListener e) {}
      72.      public void addTableModelListener(TableModelListener e) {}
      73.  
      74.      public String[][] getSaveDB() {
      75.          return saveDB;
      76.      }
      77.  }

      这一部分和之前没有多大变动，加了一个数组输入输出存储，eclipse自动报错加上去的。（74-76行）

    18. LLKMouseListener.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.awt.event.MouseAdapter;
      4.  import java.awt.event.MouseEvent;
      5.  
      6.  import javax.swing.JTable;
      7.  
      8.  public class LLKMouseListener extends MouseAdapter{
      9.      /**
      10.      1.相同图片能够消除
      11.      2.在同一行或者同一列无障碍物可消除
      12.      3.一个拐点可消除
      13.      4.两个拐点可消除
      14.      */
      15.      public MyTableModel mtm;
      16.  
      17.      //1_4.发现消除的是一个，点一个就消掉一个
      18.      //所以需要做下关联， 控制第一次还是第二次点击的操作
      19.      public boolean flag = true;
      20.      public int row1, column1, row2, column2;
      21.      //3.鼠标监控
      22.      public LLKMouseListener(MyTableModel mtm) {
      23.          this.mtm = mtm;
      24.      }
      25.  
      26.      public void mousePressed(MouseEvent e) {
      27.          //1.相同图片能够消除
      28.          // 1_1.需要知道自己点击的是表格哪个位置
      29.          // 1_2.得到被选中行被选中列
      30.          JTable table = (JTable) e.getSource();
      31.  
      32.          // 1_3.把指定位置的图片消除：去除路径
      33.          String[][] saveDB = mtm.getSaveDB();
      34.  
      35.          if(flag){
      36.              row1 = table.getSelectedRow();
      37.              column1 = table.getSelectedColumn();
      38.              flag = false;
      39.          }else{
      40.              row2 = table.getSelectedRow();
      41.              column2 = table.getSelectedColumn();
      42.              saveDB[row1][column1] = "";
      43.              saveDB[row2][column2] = "";
      44.              flag = true;
      45.          }
      46.      }
      47.  }

      到这一步已经实现任意两个图形相消除，接下来是——两个相同图形的消除。

    19. LLKMouseListener.java 
      1.  package com.edp.impl;
      2.  
      3.  import java.awt.event.MouseAdapter;
      4.  import java.awt.event.MouseEvent;
      5.  
      6.  import javax.swing.JTable;
      7.  
      8.  public class LLKMouseListener extends MouseAdapter{
      9.      /**
      10.      1.相同图片能够消除
      11.      2.在同一行或者同一列无障碍物可消除
      12.      3.一个拐点可消除
      13.      4.两个拐点可消除
      14.      */
      15.      public MyTableModel mtm;
      16.  
      17.      //1_4.发现消除的是一个，点一个就消掉一个
      18.      //所以需要做下关联， 控制第一次还是第二次点击的操作
      19.      public boolean flag = true;
      20.      public int row1, column1, row2, column2;
      21.      //3.鼠标监控
      22.      public LLKMouseListener(MyTableModel mtm) {
      23.          this.mtm = mtm;
      24.      }
      25.  
      26.      public void mousePressed(MouseEvent e) {
      27.          //1.相同图片能够消除
      28.          // 1_1.需要知道自己点击的是表格哪个位置
      29.          // 1_2.得到被选中行被选中列
      30.          JTable table = (JTable) e.getSource();
      31.  
      32.          // 1_3.把指定位置的图片消除：去除路径
      33.          String[][] saveDB = mtm.getSaveDB();
      34.  
      35.          if(flag){
      36.              row1 = table.getSelectedRow();
      37.              column1 = table.getSelectedColumn();
      38.              flag = false;
      39.          }else{
      40.              row2 = table.getSelectedRow();
      41.              column2 = table.getSelectedColumn();
      42.              if((row1 != row2 || column1 != column2)){
      43.                  if(saveDB[row1][column1].equals(saveDB[row2][column2])){
      44.                      if(checkRow(row1,column1,row2,column2)||
      45.                              checkColumn(row1,column1,row2,column2)){
      46.                          saveDB[row1][column1] = "";
      47.                          saveDB[row2][column2] = "";
      48.                      }
      49.                  }
      50.              }
      51.              flag = true;
      52.          }
      53.      }
      54.  
      55.      //同行算法
      56.      public boolean checkRow(int row1, int column1, int row2, int column2) {
      57.          // 1.保证两个位置是同一行
      58.          if (row1 == row2) {
      59.              int minColumn = Math.min(column1, column2);
      60.              int maxColumn = Math.max(column1, column2);
      61.              // 寻找两个位置之间的所有位置是否为空
      62.              for (int i = minColumn + 1; i < maxColumn; i++) {
      63.                  if (!"".equals(mtm.getSaveDB()[row1][i])) {
      64.                      return false;
      65.                  }
      66.              }
      67.              return true;
      68.          }
      69.          return false;
      70.      }
      71.  
      72.      //同列算法
      73.      public boolean checkColumn(int row1, int column1, int row2, int column2) {
      74.          // 1.保证两个位置是同一列
      75.          if (column1 == column2) {
      76.              int minRow = Math.min(row1, row2);
      77.              int maxRow = Math.max(row1, row2);
      78.              // 寻找两个位置之间的所有位置是否为空
      79.              for (int i = minRow + 1; i < maxRow; i++) {
      80.                  if (!"".equals(mtm.getSaveDB()[column1][i])) {
      81.                      return false;
      82.                  }
      83.              }
      84.              return true;
      85.          }
      86.          return false;
      87.  
      88.      }
      89.      public boolean checkOnePoint(int row1, int column1, int row2, int column2) {
      90.          return false;
      91.  
      92.      }
      93.      public boolean checkTwoPoint(int row1, int column1, int row2, int column2) {
      94.          return false;
      95.      }
      96.  
      97.  }
    20. 继续增加代码，也就是限制消除的条件（对消除提条件），因为只有鼠标监听类有做修改，所以就只放这个类的代码了。
    21. 这里实现的行和列相同图片可以消除。还剩一个拐点和两个拐点。
    22. 在写出上述代码的时候一直用   "System.out.println();"语句进行反复测试才实现代码，而且在不断增加代码中，这种测试方法会一直用。
    23. 一个拐点的实现需要利用到同行消除判断算法和同列消除判断算法。
      1. 这里主调函数没变就不放上来了。
      2. MyTableModel.java 
        1. package com.edp.impl;
        2.  
        3. import java.util.Random;
        4.  
        5. import javax.swing.ImageIcon;
        6. import javax.swing.event.TableModelListener;
        7. import javax.swing.table.TableModel;
        8.  
        9. public class MyTableModel implements TableModel {
        10.     //1.创建数组，一个持久化存储的容器:存储连连看的图片 迷宫寻路
        11.     private String[][] saveDB = new String[13][13];
        12.     //2.有图像在数组看得到
        13.     //2_2在存的时候想到图片最好随机
        14.     private Random ran = new Random();//创建随机对象
        15.     //2_1 把图片存到数组
        16.     //3.消除肯定要用鼠标点呀点的。而实现鼠标操作，肯定是要监控。
        17.     public MyTableModel() {
        18.         int value;
        19.         for(int i = 0;i<saveDB.length;i++){
        20.             for (int j = 0; j < saveDB[i].length; j++) {
        21.                 value = ran.nextInt(13)+1;
        22.                 saveDB[i][j] = "image/"+value+".jpg";
        23.             }
        24.         }
        25.     }
        26.  
        27.     //获取列类型
        28.     public Class<?> getColumnClass(int columnIndex) {
        29.         return javax.swing.ImageIcon.class;
        30.     }
        31.     //获取总行数
        32.     public int getRowCount() {
        33.         return saveDB.length;
        34.     }
        35.     //获取总列数
        36.     public int getColumnCount() {
        37.         //这里考虑一个bug：如果连列数都没有，这行代码就会报出异常
        38.         if(saveDB.length>0){
        39.             return saveDB[0].length;
        40.         }
        41.         return 0;
        42.     }
        43.     //获取表格列名
        44.     public String getColumnName(int columnIndex) {
        45.         //连连看游戏没必要出现表格列名呀，反正不需要
        46.         //实现列名可以通过switch语句，最适合实现。然后在TableFrame类里面实现
        47.         //不过想要实现得这样(用到JScrollPane)：
        48.         //    JTable table = new JTable(mtm);
        49.         //    //把JTable对象加载到JScrollPane
        50.         //      JScrollPane jsp = new JScrollPane(table);
        51.         //    this.add(jsp);
        52.         //JScrollPane到底是个什么玩意，请自己去查java API说明书。
        53.         return null;
        54.     }
        55.     //设置单元格数据
        56.     public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        57.          saveDB[rowIndex][columnIndex] = (String)aValue;
        58.     }
        59.     //获得单元格数据
        60.     public Object getValueAt(int rowIndex, int columnIndex) {
        61.         //返回图片
        62.         ImageIcon icon = new ImageIcon(saveDB[rowIndex][columnIndex]);
        63.         return icon;
        64.  
        65.     }
        66.     //单元格是否编辑
        67.     public boolean isCellEditable(int rowIndex, int columnIndex) {
        68.         //连连看游戏肯定不需要对单元格进行修改或删除，游戏逻辑自会处理相关格子内的东西。
        69.         return false;
        70.     }
        71.     public void removeTableModelListener(TableModelListener e) {}
        72.     public void addTableModelListener(TableModelListener e) {}
        73.  
        74.     public String[][] getSaveDB() {
        75.         return saveDB;
        76.     }
        77. }
      3. LLKMouseListener.java ，该有的说明都在代码里面，思路按标的序号自己看。 
        1. package com.edp.impl;
        2.  
        3. import java.awt.event.MouseAdapter;
        4. import java.awt.event.MouseEvent;
        5.  
        6. import javax.swing.JTable;
        7.  
        8. public class LLKMouseListener extends MouseAdapter{
        9.     /**
        10.      * 鼠标键控
        11.      * 1.相同图片能够消除
        12.      * 2.在同一行或者同一列无障碍物可消除
        13.      * 3.一个拐点可消除
        14.      * 4.两个拐点可消除
        15.      *
        16.      */
        17.     public MyTableModel mtm;
        18.  
        19.     //1_4.发现消除的是一个，点一个就消掉一个
        20.     //所以需要做下关联， 控制第一次还是第二次点击的操作
        21.     public boolean flag = true;
        22.     public int row1, column1, row2, column2;
        23.     public LLKMouseListener(MyTableModel mtm) {
        24.         this.mtm = mtm;
        25.     }
        26.  
        27.     public void mousePressed(MouseEvent e) {
        28.         //1.相同图片能够消除
        29.         // 1_1.需要知道自己点击的是表格哪个位置
        30.         // 1_2.得到被选中行被选中列
        31.         JTable table = (JTable) e.getSource();
        32.  
        33.         // 1_3.把指定位置的图片消除：去除路径
        34.         String[][] saveDB = mtm.getSaveDB();
        35.  
        36.         if(flag){
        37.             row1 = table.getSelectedRow();
        38.             column1 = table.getSelectedColumn();
        39.             flag = false;
        40.         }else{
        41.             row2 = table.getSelectedRow();
        42.             column2 = table.getSelectedColumn();
        43.             if((row1 != row2 || column1 != column2)){
        44.                 if(saveDB[row1][column1].equals(saveDB[row2][column2])){
        45.                     if(checkRow(row1,column1,row2,column2)
        46.                             || checkColumn(row1,column1,row2,column2)
        47.                             || checkOnePoint(row1,column1,row2,column2)
        48.                             || checkTwoPoint(row1,column1,row2,column2)){
        49.                         saveDB[row1][column1] = "";
        50.                         saveDB[row2][column2] = "";
        51.                     }
        52.                 }
        53.             }
        54.  
        55.             flag = true;
        56.         }
        57.     }
        58.  
        59.     //2_1.同行算法,保证两个位置是同一行
        60.     public boolean checkRow(int row1, int column1, int row2, int column2) {
        61.  
        62.         if (row1 == row2) {
        63.             int minColumn = Math.min(column1, column2);
        64.             int maxColumn = Math.max(column1, column2);
        65.             // 寻找两个位置之间的所有位置是否为空
        66.             for (int i = minColumn + 1; i < maxColumn; i++) {
        67.                 if (!"".equals(mtm.getSaveDB()[row1][i])) {
        68.                     return false;
        69.                 }
        70.             }
        71.             return true;
        72.         }
        73.         return false;
        74.     }
        75.  
        76.     //2_2.同列算法,保证两个位置是同一列
        77.     public boolean checkColumn(int row1, int column1, int row2, int column2) {
        78.  
        79.         if (column1 == column2) {
        80.             int minRow = Math.min(row1, row2);
        81.             int maxRow = Math.max(row1, row2);
        82.             // 寻找两个位置之间的所有位置是否为空
        83.             for (int i = minRow + 1; i < maxRow; i++) {
        84.                 if (!"".equals(mtm.getSaveDB()[i][column1])) {
        85.                     return false;
        86.                 }
        87.             }
        88.             return true;
        89.         }
        90.         return false;
        91.  
        92.     }
        93.  
        94.     //2_3.一个拐点算法
        95.     public boolean checkOnePoint(int row1, int column1, int row2, int column2) {
        96.         //先寻找拐点坐标(row1,column2),(row2 column1)
        97.         if("".equals(mtm.getSaveDB()[row1][column2])&&
        98.                 checkRow(row1, column2, row1, column1)&&
        99.                 checkColumn(row1, column2, row2, column2)){
        100.             return true;
        101.         }
        102.         if("".equals(mtm.getSaveDB()[row2][column1])&&
        103.                 checkRow(row2, column1, row2, column2)&&
        104.                 checkColumn(row2, column1, row1, column1)){
        105.             return true;
        106.         }
        107.         return false;
        108.     }
        109.  
        110.     //2_4.两个拐点算法
        111.     public boolean checkTwoPoint(int row1, int column1, int row2, int column2) {
        112.         //2_4_1.向左判断,各方向判断都是无数个“一个拐点”算法集合在一起。
        113.         for(int rowLeft = row1 - 1 ; mtm.getSaveDB()[rowLeft][column1] == "" && rowLeft >= 0 ; rowLeft --){
        114.              if(checkOnePoint(rowLeft,column1,row2,column2)){
        115.                  return true;
        116.              }
        117.         }
        118.         //2_4_1.向右判断
        119.         for(int rowRight = row1 + 1; rowRight <= mtm.getSaveDB()[0].length && mtm.getSaveDB()[rowRight][column1] == "" ; rowRight ++){
        120.              if(checkOnePoint(rowRight,column1,row2,column2)){
        121.                  return true;
        122.              }
        123.         }
        124.         //2_4_1.向上判断
        125.         for(int columnUp = column1 - 1 ; columnUp >= 0 && mtm.getSaveDB()[row1][columnUp] == ""; columnUp --){
        126.              if(checkOnePoint(row1,columnUp,row2,column2)){
        127.                  return true;
        128.              }
        129.         }
        130.         //2_4_1.向下判断
        131.         for(int columnDown = column1 + 1 ; columnDown <= mtm.getSaveDB().length && mtm.getSaveDB()[row1][columnDown] == "" ; columnDown ++){
        132.              if(checkOnePoint(row1,columnDown,row2,column2)){
        133.                  return true;
        134.              }
        135.         }
        136.         return false;
        137.     }
        138.  
        139. }
      4. 到这一步基本实现可玩性，但还有两个bug没有解决。
    24. 第一个bug：边缘消除无法实现
    25. 第二个bug：消除图片不是成双出现，而是单个随机出现的。

【代码笔记】Java连连看项目的实现(2)——JTable 、TableModel的使用的更多相关文章

  1. 【代码笔记】Java连连看项目的实现(1)——JTable 、TableModel的使用

    javax.swing.table.TableModel和javax.swing.JTable JTable .TableModel是Java里面画表格的包. TableModel:为Table提供显 ...

  2. Java学习笔记三十:Java小项目之租车系统

    Java小项目之租车系统 一:项目背景介绍: 根据所学知识,编写一个控制台版的“呱呱租车系统” 功能: 1.展示所有可租车辆: 2.选择车型.租车量: 3.展示租车清单,包含:总金额.总载货量以及其车 ...

  3. 项目管理---git----快速使用git笔记(五)------本地项目代码提交到远程仓库---新建项目

    上一篇我们已经知道了怎么从远程仓库获取项目文件代码. 项目管理---git----快速使用git笔记(四)------远程项目代码的首次获取 git还有一种使用场景是 我本来在电脑里就有一个项目,现在 ...

  4. Docker学习笔记五：Docker生成jenkins容器，支持Java Web项目持续集成、持续部署

    一.创建jenkins容器: 1.拉取jeknin镜像 sudo docker pull jenkins 2.创建一个jenkins目录 sudo mkdir /jenkins 3.在jenkins目 ...

  5. Android学习笔记_32_通过WebView实现JS代码与Java代码互相通信

    webview两种实现方法,覆盖onKeyDown()方法 缓存 WebSettings应用注意的几个问题 1.要实现JS代码与Java代码互相通信,需要通过Android的WebView控件,在视图 ...

  6. java web项目由http转换成https遇到的各种坑

    java web项目由http转换成https遇到的各种坑 这篇文章写给自己在经历项目由http转换成https遇到的各种坑所做的一份笔记,留给以后自己看,或者和开发的朋友也刚好遇到和我一样的问题的朋 ...

  7. 使用Spring Boot来加速Java web项目的开发

    我想,现在企业级的Java web项目应该或多或少都会使用到Spring框架的. 回首我们以前使用Spring框架的时候,我们需要首先在(如果你使用Maven的话)pom文件中增加对相关的的依赖(使用 ...

  8. Linux(Centos)之安装tomcat并且部署Java Web项目

    1.准备工作 a.下载tomcat linux的包,地址:http://tomcat.apache.org/download-80.cgi,我们下载的版本是8.0,下载方式如图:          b ...

  9. 【转】Java Web 项目获取运行时路径 classpath

    Java Web 项目获取运行时路径 classpath 假设资源文件放在maven工程的 src/main/resources 资源文件夹下,源码文件放在 src/main/java/下, 那么ja ...

随机推荐

  1. 安装GCC-8.3.0及其依赖

    目录 目录 1 1. 前言 1 2. 安装日期 1 3. GCC国内镜像下载地址 2 4. GCC的依赖库 2 4.1. gmp库 2 4.2. mpfr库 2 4.3. mpc库 2 4.4. m4 ...

  2. SDK 开发 .a .framework .bundle (xcode引用) 依赖sdk工程

    一. 静态库.a 1.创建静态库工程 Cocoa Touch Static Libray  ,然后可以创建一个测试视图 TestView 2.暴露头文件 -> Build Phases--> ...

  3. IntelliJ IDEA(Android Studio)设置代码的快捷编辑模板Live Templates

    1.file---->setttings 2.editor--->live template 3.点击右侧的+ 4.设置模板 注意:Abbreviation为代码模板的缩写.

  4. [FJOI2017]矩阵填数

    [Luogu3813] [LOJ2280] 写得很好的题解 \(1.\)离散化出每一块内部不互相影响的块 \(2.\)\(dp[i][j]\)为前 \(i\) 种重叠块其中有 \(j\) 这些状态的矩 ...

  5. 洛谷 P3332 BZOJ 3110 [ZJOI2013]K大数查询

    题目链接 洛谷 bzoj 题解 整体二分 Code #include<bits/stdc++.h> #define LL long long #define RG register usi ...

  6. 非阻塞模式ServerSocketChannel 聊天室服务器端

    import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import ja ...

  7. Java swing中的keyListener使用事例

    最近在学习Java swing,写了一个域内聊天室,实现用户登录ip,端口号之后,进入聊天窗口聊天: 通过菜单条增加了几个功能,边框,字体,颜色和文件传输.风格里的样式都可以通过自己选择来设置. 介绍 ...

  8. The user specified as a definer ('root'@'%') does not exist解决方案

    今天操作以root身份操作MySQL数据库的时候报出了这个异常: Error updating database. Cause: java.sql.SQLException: The user spe ...

  9. linux 运维基础测验题

    第一题:创建一个目录/data --> mkdir /data eg: ls  -d 显示命令    -l 详细信息    -a 显示所有文件 cd 打开目录 pwd 显示当前目录 第二题:在/ ...

  10. 面向切面编程 （AOP ）

    什么是面向切面编程? 面向切面编程就是(AOP --- aspect-oriented programming), 在百科上说: 面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一 ...