java实现2048

最新推荐文章于 2024-07-28 11:28:22 发布
最新推荐文章于 2024-07-28 11:28:22 发布
阅读量3.3k 收藏 22
点赞数
文章标签： java 游戏 jtable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neverlesspray/article/details/52026281
版权 
2048是一款逻辑比较简单的小游戏，涉及到的几个知识点有JTable绘制表格，显示数值和颜色;keyListener 监听用户按键事件，并在keyPress（）中做出相应动作。
1.初始化 init()
2.用户按键：判断是否可以移动，移动完后判断是否还有空格子，如果有空格子在随机产生的位置处设置2或4
3.判断游戏是否结束，若结束，判断用户是否胜利

运行场景

运行结束
Game.java:

   import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import javax.swing.border.EtchedBorder;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;

public class Game extends JFrame implements KeyListener {
    private JPanel p;
    private JTable table;
    private JLabel label, scoreshow;
    Boolean hasBlank;//值为true时有空格子
    String[][] params;
    int score = 0;
    String gameResult="你输了！";
    public Game() {
        this.setTitle("2048");
        p = new JPanel();
        p.setLayout(null);
        label = new JLabel("SCORE:");
        scoreshow = new JLabel();
        scoreshow.setBounds(60, 0, 100, 50);
        label.setBounds(0, 0, 50, 50);
        table = new JTable(4, 4);
        table.setRowHeight(90);
        table.setEnabled(false);
        table.setBounds(0, 50, 400, 400);
        setFont(new Font("font", Font.PLAIN, 40));
        table.setBorder(new EtchedBorder(Color.BLACK, Color.LIGHT_GRAY));
        p.add(table);
        p.add(label);
        p.add(scoreshow);
        this.add(p);
        this.setLocation(500, 300);
        this.setSize(400, 438);
        this.setVisible(true);
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.addKeyListener(this);
        init();
    }

    public void init() {
        System.out.println("初始化init()");
        score = 0;
        hasBlank = true;
        params = new String[4][4];
        randomInsert();
        randomInsert();
        setTableValue();
    }

    public void randomInsert() {
        System.out.println(hasBlank);
        while (hasBlank) {
            int x = (int) (Math.random() * 4);
            int y = (int) (Math.random() * 4);
            if (params[x][y] == null) {
                if (Math.random() < 0.5d) {
                    params[x][y] = String.valueOf(2);
                } else {
                    params[x][y] = String.valueOf(4);
                }
                break;
            }
        }
    }

    public void hasBlank() {
        boolean empty=false;//是否跳出循环的标志
        hasBlank=false;
        System.out.println("把hasBlank置为false为了下次的判断");
        System.out.println("判断是否有空格子！hasBlank()");
        for (int i = 0; i < 4&&!empty; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.println("我在hasBlank.for()这里卡住啦！ ");
                if (params[i][j] == null) {
                    empty=true;
                    hasBlank = true;
                    break;

                }
            }
        }

    }

    public void setTableValue() {
        DefaultTableModel model = (DefaultTableModel) this.table.getModel();
        int rowcount = model.getRowCount();
        while (rowcount > 0) {
            model.removeRow(0);
            rowcount--;
        }
//      showParams();
        for (int i = 0; i < 4; i++) {
            model.addRow(params[i]);
        }

        this.table.setModel(model);
        this.table.setFont(new Font("font", Font.PLAIN, 40));

        for (int i = 0; i < 4; i++) {
            table.getColumn(model.getColumnName(i)).setCellRenderer(
                    new MyTableCellRenderrer());
        }
        scoreshow.setText(score + "");
    }

    public String add(String a) {
        if (a != null) {
            return String.valueOf(Integer.valueOf(a) * 2);
        }
        return null;
    }

    public Boolean compara(String a, String b) {
        if (a == null) {
            if (b == null) {
                return true;
            } else {
                return false;
            }
        } else {
            if (b == null) {
                return false;
            } else {
                if (a.equals(b)) {
                    return true;
                } else {
                    return false;
                }
            }
        }
    }
//若返回值为false，则游戏结束
    public Boolean isGameOver() {
        boolean jump=false;//游戏是否结束的标志
        System.out.println("判断游戏是否结束！isGameOver()");
        if (hasBlank == false) {
            for (int i = 0; i < 3&&!jump; i++) {
                for (int j = 0; j < 3; j++) {
                    if (compara(params[i][j], params[i + 1][j])
                            || compara(params[i][j], params[i][j + 1])) {
                        jump=true;
                        break;

                    }
                }
            }
        }else{
            jump=true;
}
        return jump;
    }
//重新开始游戏
    public void start(){    
             System.out.println("重新开始游戏！start()");
         int isRestart = JOptionPane.showConfirmDialog(this,gameResult+" 是否重新开始？", "重新开始", JOptionPane.YES_NO_OPTION);                      if (isRestart == JOptionPane.YES_OPTION) {
                                init();
                        }

}

    public void up() {
        System.out.println("向上移动");
        for (int j = 0; j < 4; j++) {
            upclear();
            for (int i = 0; i < 3; i++) {
                if (params[0][j] != null) {
                    if (compara(params[i][j], params[i + 1][j])) {
                        params[i][j] = add(params[i][j]);
                        params[i + 1][j] = null;
                        if (params[i][j] != null)
                            score += Integer.valueOf(params[i][j]);
                    }
                }
            }
            upclear();
        }
    }

    public void down() {
        System.out.println("向下移动");
        for (int j = 0; j < 4; j++) {
            downclear();
            for (int i = 3; i > 0; i--) {
                if (params[3][j] != null) {
                    if (compara(params[i][j], params[i - 1][j])) {
                        params[i][j] = add(params[i][j]);
                        params[i - 1][j] = null;
                        if (params[i][j] != null)
                            score += Integer.valueOf(params[i][j]);

                    }
                }
            }
            downclear();
        }
    }

    public void left() {
        System.out.println("向左移动");
        for (int i = 0; i < 4; i++) {
            leftclear();
            for (int j = 0; j < 3; j++) {
                if (params[i][0] != null) {
                    if (compara(params[i][j], params[i][j + 1])) {
                        params[i][j] = add(params[i][j + 1]);
                        params[i][j + 1] = null;
                        if (params[i][j] != null)
                            score += Integer.valueOf(params[i][j]);
                    }
                }
            }
            leftclear();
        }
    }

    public void right() {
        System.out.println("向右移动");
        for (int i = 0; i < 4; i++) {
            rightclear();
            for (int j = 3; j > 0; j--) {
                if (params[i][3] != null) {
                    if (compara(params[i][j], params[i][j - 1])) {
                        params[i][j] = add(params[i][j]);
                        params[i][j - 1] = null;
                        if (params[i][j] != null)
                            score += Integer.valueOf(params[i][j]);
                    }
                }
            }
            rightclear();
        }
    }

    public void upclear() {
        System.out.println("清空向上");
        for (int j = 0; j < 4; j++) {
            for (int i = 0; i < 3; i++) {
                int k = i;
                while (k >= 0 && params[k][j] == null) {
                    params[k][j] = params[k + 1][j];
                    params[k + 1][j] = null;
                    k--;
                }
            }
        }
    }

    public void downclear() {
        System.out.println("清空向下");
        for (int j = 0; j < 4; j++) {
            for (int i = 3; i > 0; i--) {
                int k = i;
                while (k > 0 && params[k][j] == null) {
                    params[k][j] = params[k - 1][j];
                    params[k - 1][j] = null;
                    k--;
                }
            }
        }
    }

    public void leftclear() {
        System.out.println("清空左");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 3; j++) {
                int k = j;
                while (k >= 0 && params[i][k] == null) {
                    params[i][k] = params[i][k + 1];
                    params[i][k + 1] = null;
                    k--;
                }
            }
        }
    }

    public void rightclear() {
        System.out.println("清空向右");
        for (int i = 0; i < 4; i++) {
            for (int j = 3; j > 0; j--) {
                int k = j;
                while (k > 0 && params[i][k] == null) {
                    params[i][k] = params[i][k - 1];
                    params[i][k - 1] = null;
                    k--;
                }
            }
        }
    }

    public Boolean canRorL() {
        if (hasBlank == false) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (compara(params[i][j], params[i][j + 1])) {
                        return true;
                    }
                }
            }
            return false;
        }
        return true;
    }

    public Boolean canUorD() {
        if (hasBlank == false) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (compara(params[i][j], params[i + 1][j])) {
                        return true;
                    }
                }
            }
            return false;
        }
        return true;
    }
//流程：
    public void go(){
        randomInsert();
        setTableValue();
        if(isGameOver()==false){
            System.out.println("游戏结束！");
            if(win()){
                System.out.println("你赢了！");
}else{
            System.out.println("你输了！");
}
            start();
}


}
//Interface的方法全部都要覆盖
    @Override
    public void keyTyped(KeyEvent e) {
    }

    @Override
    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_UP) {
//          hasBlank();//先判断完是否能够移动并且移动完再次判断是否有空格子，不然当有相同的格子但是没有空格
//子时系统会认为无法移动，一直卡在判断是否有空格子这里
            if (canUorD()) {
                //hasBlank();
                up();
                hasBlank();
                go();
            }

        }
        if (key == KeyEvent.VK_DOWN) {
//          hasBlank();
            if (canUorD()) {
//              hasBlank();
                down();
                hasBlank();
                go();
            }

        }
        if (key == KeyEvent.VK_LEFT) {
//          hasBlank();
            if (canRorL()) {
    //          hasBlank();
                left();
                hasBlank();
                go();
            }

        }
        if (key == KeyEvent.VK_RIGHT) {
//          hasBlank();
            if (canRorL()) {
        //      hasBlank();
                right();
                hasBlank();
                go();
            }
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
    }
//返回值为true则游戏胜利
    public Boolean win(){
        System.out.println("判断是否赢了！win()");
        boolean winYes=false;
        for(int i=0;i<4&&!winYes;i++){
            for(int j=0;j<4;j++){
                int value=Integer.parseInt(params[i][j]);
                if(value>=2048){
                    winYes=true;
                    gameResult="你赢了！";
                    break;
}



    public static void main(String[] args) {
        new Game();
    }

    class MyTableCellRenderrer extends DefaultTableCellRenderer {
        // 设置单元格内容居中
        @Override
        public void setHorizontalAlignment(int alignment) {
            super.setHorizontalAlignment(SwingConstants.CENTER);
        }

        // 设置单元格颜色
        @Override
        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
            Component component = super.getTableCellRendererComponent(table, value,
                    isSelected, hasFocus, row, column);
            int v = 0;
            if (value != null && value != "")
                v = Integer.valueOf(value.toString());
            switch (v) {
            case 2:
                setBackground(new Color(255, 237, 210));
                break;
            case 4:
                setBackground(new Color(255, 228, 180));
                break;
            case 8:
                setBackground(new Color(255, 218, 185));
                break;
            case 16:
                setBackground(new Color(249, 175, 116));
                break;
            case 32:
                setBackground(new Color(248, 149, 90));
                break;
            case 64:
                setBackground(new Color(249, 94, 50));
                break;
            case 128:
                setBackground(new Color(239, 207, 108));
                break;
            case 256:
                setBackground(new Color(239, 207, 99));
                break;
            case 512:
                setBackground(new Color(239, 203, 82));
                break;
            case 1024:
                setBackground(new Color(239, 199, 57));
                break;
            case 2048:
                setBackground(new Color(239, 195, 41));
                break;
            case 4096:
                setBackground(new Color(255, 100, 57));
                break;
            default:
                component.setBackground(Color.LIGHT_GRAY);
                break;
            }
            return component;
        }
    }

}
neverzz
关注
【经典例子】Java实现2048小游戏（附带源码）
m0_46013789的博客
02-05 1783
2048游戏是一款数字益智游戏，目标是通过合并相同数字的方块来达到2048这个目标。游戏在一个4x4的方格上进行，每个方格上都有一个数字（初始时为2或4）。玩家可以通过滑动方向键（上、下、左、右）来移动所有的方块，当两个相同数字的方块在移动过程中碰到一起时，它们会合并成一个数字的方块，数字为它们的和。每次滑动后，系统会在空白的方格上随机生成一个新的数字方块。游戏的目标是通过不断合并方块，最终得到一个数字为2048的方块。
Java实现2048小游戏（附带源码）
06-04
源码见附件，下载下来直接可运行，亲测可用，每一步都详细做了注释，特别适合新手学习 源码见附件，下载下来直接可运行，亲测可用，每一步都详细做了注释，特别适合新手学习 源码见附件，下载下来直接可运行，亲测...
Java实现的小游戏2048
06-08
使用Java开发的2048,完美运行,同时游戏支持菜单栏,Java课程设计
java编写的2048程序
cjc211322的专栏
10-30 7538
java编写的2048游戏程序
Java面向对象课程设计——2048小游戏项目（附源码）
最新发布
J^T的博客
07-28 1111
在Java面向对象程序设计的广阔领域中，通过实际项目来加深理论知识与实践技能的结合是一个不可或缺的过程。本项目2048游戏的设计与实现，不仅是一个对Java基础知识的全面应用，更是对面向对象编程思想的一次深刻实践。通过此项目，我们将学习到如何使用JFrame来构建图形用户界面（GUI），如何利用JPanel作为游戏的主要画布，以及如何通过监听键盘事件来实现方块的移动与合并。此外，本项目还涉及到了数据的持久化存储，即将用户的游戏分数与最高分记录到文件中，以便下次游戏时能够显示历史最高成绩。
java项目---2048
llt2997632602的博客
07-18 1400
2048》 是一款比较流行的数字游戏，最早于2014年3月20日发行。原版2048首先在GitHub上发布，原作者是Gabriele Cirulli，后被移植到各个平台。//x坐标//y坐标//高//宽//下标//下标//偏移量//数字//是否合并this.i = i;this.j = j;cal();//卡片的绘制//设置新颜色//绘制数字if(num!= 0) {Font font = new Font("思源宋体",Font.BOLD,35);
Java游戏2048
06-25
用java写的2048小游戏。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
JAVA 实现《2048游戏》游戏
热门推荐
毅慎的博客
03-06 1万+
JAVA 实现《2048游戏》游戏
用java实现2048小游戏的实验报告
02-18
用java实现2048小游戏的实验报告，内容齐全可用于期末大作业 用java实现2048小游戏的实验报告，内容齐全可用于期末大作业
java实现2048游戏源代码
08-18
Java 实现 2048 游戏源代码 Java 实现 2048 游戏源代码是使用 Java 语言开发的游戏源代码，主要功能包括游戏初始化、格子的移动、新的格子生成、判赢和判输等。 游戏初始化：在游戏开始时，会创建一个 4x4 的宫格...
Java实现2048小游戏
04-29
《Java实现2048小游戏详解》 2048是一款深受玩家喜爱的数字益智游戏，其核心玩法是通过上下左右滑动棋盘，使相同数字的方块合并成更大的数字，目标是达到2048这个数字。在这个专题中，我们将深入探讨如何使用Java...
Java版2048
12-23
用jc myeclipse都能跑，全图形界面。
基于JAVA开发的2048小游戏
09-28
用Java开发出的2048小游戏，简单易上手，还有PPT介绍哦
2048游戏java版
11-26
自己写的2048游戏，java课堂作业
java小游戏2048
04-28
java2048java2048java2048java2048java2048java2048java2048
java实现2048小游戏
guyan1111的博客
05-05 2218
对于java初学者来说，通过一些学习小游戏来对swing学习以及对java基础的学习是一个好的方法，同时也给学习带来了很多的乐趣，接下来就给大家分享一个java实现的2048小游戏。 废话不多说，直接上代码。大家可以直接通过下面的代码实现，也可以关注公众号“程序员的事儿”回复“2048”获取完整代码。 import java.util.Date; import java.util.Rand...
2048 java代码_java实现的2048游戏完整实例
weixin_39615991的博客
02-12 522
本文实例讲述了java实现的2048游戏。分享给大家供大家参考，具体如下：先来看看运行效果：具体代码如下：package awtDemo;import javax.swing.*;import java.awt.*;import java.awt.event.*;import java.io.*;import java.util.*;@SuppressWarnings("serial")publi...
java2048_java之2048
weixin_42361026的博客
02-21 400
今天好热热热热热热热热热 ㄟ(≧◇≦)ㄏ ，所以吃块西瓜就开始玩2048吧~一.先确定这个2048有哪些功能初始出现2个数字和方块移动方块方块中的数字相加仅出现1个相加后的数字和方块记录最大数字随机出现数字和方块游戏结束排行榜重新开始游戏存档二.界面的实现以画图的方式来实现2048游戏主界面。☆窗体实现☆游戏界面实现Graphics的绘图方法☆基本功能实现三.实现2048游戏需要使用那些API类...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值