Java-Swing俄罗斯方块

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量2.6k 收藏 4
点赞数
分类专栏： java 文章标签： java 开发语言 后端 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57098080/article/details/122521807
版权

1.效果图

2. 实现的过程

Step1：先画面板

主要是三个方法：initWindow()初始化窗口，initGameInit()初始化面板；initExplainPanel()初始化解释面板，init()初始化参数

public void initWindow(){
        this.setSize(600, 850);
        this.setLocationRelativeTo(null);
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
        this.setTitle("俄罗斯方块");
    }

    public void initGameInit(){
        JPanel game_main=new JPanel();
        game_main.setLayout(new GridLayout(game_x,game_y,1,1));
        for(int i=0;i<text.length;i++){
            for(int j=0;j<text[i].length;j++){
                text[i][j]=new JTextArea(game_x,game_y);
                text[i][j].setBackground(Color.WHITE);
                text[i][j].addKeyListener(this);
                if((j==0) || (j==text[i].length-1) || (i==text.length-1)){
                    text[i][j].setBackground(Color.MAGENTA);
                    data[i][j]=1;
                }
                text[i][j].setEditable(false);
                game_main.add(text[i][j]);
            }
        }
        this.setLayout(new BorderLayout());
        this.add(game_main,BorderLayout.CENTER);
    }

    public void initExplainPanel(){
        JPanel explain_left=new JPanel();
        JPanel explain_right=new JPanel();
        explain_left.setLayout(new GridLayout(4,1));
        explain_right.setLayout(new GridLayout(2,1));
        explain_left.add(new JLabel("按空格键，方块变形"));
        explain_left.add(new JLabel("按左箭头，方块左移"));
        explain_left.add(new JLabel("按右箭头，方块右移"));
        explain_left.add(new JLabel("按下箭头，方块下落"));
      //  explain_left.add(new JLabel("按'P'，游戏暂停"));
        label1.setForeground(Color.red);
        explain_right.add(label);
        explain_right.add(label1);
        this.add(explain_left,BorderLayout.WEST);
        this.add(explain_right,BorderLayout.EAST);

    }
    /***
     * 初始化
     */
    private void init() {
        text=new JTextArea[game_x][game_y];
        data=new int[game_x][game_y];
        label1=new JLabel("游戏状态：正在游戏中");
        label=new JLabel("游戏分数为：0");
        isRunning=true;
        allRect=new int[]{0x00cc,0x8888,0x000f,0x888f,0xf8888,0xf111,0x111f,0x0eee,0xffff,0x0008,0x0888,0x000e,0x0088,0x000c
        ,0x08c8,0x00e4,0x04c4,0x004e,0x08c4,0x006c,0x04c8,0x00c6};
    }

Step2:参数设定以及生成方块

参数：

 private static final int game_x=26;
    private static final int game_y=12;
    JTextArea[][] text;
    int[][] data;
    JLabel label1;
    JLabel label;
    boolean isRunning;
    int[] allRect;//存放所有方块
    int rect;//存储当前方块的变量
    //当前方块的坐标
    int x,y;
    //线程休眠时间
    int time=1000;
    int score=0;
    boolean game_pause=false;
    int pause_time=0;

 方块：

方块的表示方法我是用十六进制数进行表示

首先看一下一个方块：

 其他的方块都可以这样表示：

 

 

 /**8
     * 生成一个随机的方块
     */
    public void ranRect(){
        Random random=new Random();
        rect=allRect[random.nextInt(22)];
    }

 Step3：设置游戏开始： 

其中包括的方法主要是：game_run(),先随机生成方块，再判断方块是否可以下落，如果可以下落，先改变data的值表示这里有方块，再判断移除的条件，最后判断游戏失败的条件

 public void game_begin(){
        while(true){
            if(!isRunning){
                break;
            }
            game_run();
        }
        label1.setText("游戏状态：游戏结束！");
    }

    /***
     * 游戏run
     */
    private void game_run()  {
        ranRect();
        x=0;
        y=5;
        for(int i=0;i<game_x;i++){
            try {
                Thread.sleep(time);
                if(game_pause){
                    i--;
                }else{
                    //判断方块是否可以下落
                    if(!canFall(x,y)){
                        //将data置为1，表示有方块占用
                        changData(x,y);
                        //4是表示方块是4*4的方块
                        for(int j=x;j<x+4;j++){
                            int sum=0;
                            for(int k=1;k<=(game_y-2);k++){
                                /***
                                 * 表示这里有方块
                                 * sum+1
                                 */
                                if(data[j][k]==1){
                                    sum++;
                                }
                            }
                            /***
                             * 如果sum为game_y-2
                             * 说明这行可以消除
                             */
                            if(sum==(game_y-2)){
                                removeRow(j);
                            }
                        }
                        /**8
                         * 游戏失败的条件是：
                         * 前四行有方块
                         * 只需要第四行有方块就游戏结束
                         */
                        for(int j=1;j<=(game_y-2);j++){
                            if(data[3][j]==1){
                                isRunning=false;
                                break;
                            }
                        }
                        break;
                    }else{
                        x++;
                        //方块下落一格
                        fall(x,y);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

 方块是否可以下落：直接通过data数组进行判断，之间在下落的时间会将data数组的i，j位置置于1，如果此时该位置的data数组不为1就可以下落

private boolean canFall(int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    //判断该位置的下一行是否有方块
                    if(data[x+1][y]==1){
                        return false;
                    }
                }
                y++;
                temp = temp >> 1;
            }
            x++;
            y=y-4;
        }
        return true;
    }

下落的方法：直接清除掉上一层的方块，再重新绘制下一层的方块

 /**
     * 方块下落
     * @param m
     * @param n
     */
    private void fall(int m,int n) {
        if(m>0){
            //清除上一层的方块
            clear(m-1,n);
        }
        //重新绘制
        draw(m,n);
    }

    /***
     * 绘制方块
     * @param m
     * @param n
     */
    private void draw(int m, int n) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    text[m][n].setBackground(Color.BLUE);
                }
                n++;
                temp = temp >> 1;
            }
            m++;
            n=n-4;
        }
    }

    /**
     * 清除这行
     * 就是将文本域的颜色设为白色就可
     * @param m
     * @param n
     */
    private void clear(int m, int n) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    text[m][n].setBackground(Color.WHITE);
                }
                n++;
                temp = temp >> 1;
            }
            m++;
            n=n-4;
        }
    }

当有一行可以消除时，移除某一行方法：主要是通过改变文本块颜色进行移除

  /***
     * 移除某一行
     * @param row
     */
    private void removeRow(int row) {
        int temp=100;
        for(int i=row;i>=1;i--){
           for(int j=1;j<(game_y-2);j++){
               data[i][j]=data[i-1][j];
           }
        }
       //刷新游戏区域
        reflesh(row);
       //游戏加速
        if(time>temp){
            time-=temp;
        }
        score+=temp;
        label.setText("游戏得分： "+score);
    }

    private void reflesh(int row) {
        for(int i=row;i>=1;i--){
            for(int j=1;j<(game_y-2);j++){
                if(data[i][j]>=1){
                    text[i][j].setBackground(Color.BLUE);
                }else{
                    text[i][j].setBackground(Color.WHITE);
                }
            }
        }
    }

改变data值：

private void changData(int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                   data[x][y]=1;
                }
                y++;
                temp = temp >> 1;
            }
            x++;
            y=y-4;
        }
    }

Step4：鼠标监听事件：

通过进行鼠标的左移、右移、下移、变形进行操作，主要是继承KeyListener重写三个方法

这里主要是进行变形的时候需要注意

 @Override
    public void keyTyped(KeyEvent e) {
        if(e.getKeyChar()=='p'){
            if(! isRunning){
                return;
            }
            pause_time++;
            if(pause_time==1){
                game_pause=true;
                label1.setText("游戏暂停");
            }
            if(pause_time==2){
                game_pause=false;
                pause_time=0;
                label1.setText("游戏继续");
            }
        }
        if(e.getKeyChar()==KeyEvent.VK_SPACE){
            if(! isRunning){
                return;
            }
            if(game_pause){
                return;
            }
            int old;
            for(old=0;old<allRect.length;old++){
                if(rect==allRect[old]){
                    break;
                }
            }
            int next;
            if(old==0||old==7||old==8||old==9){
                return;
            }
            clear(x,y);
            if(old==1 || old==2){
                next=allRect[old==1 ?2:1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old>=3 && old<=6){
                next=allRect[old+1>6 ? 3:old+1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==10 || old==11){
                next=allRect[old==10 ?11:10];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==12 || old==13){
                next=allRect[old==12 ?13:12];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old>=14 && old<=17){
                next=allRect[old+1>17 ? 14:old+1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==18 || old==19){
                next=allRect[old==18 ?19:18];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==20 || old==21){
                next=allRect[old==20 ?21:20];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            draw(x,y);
        }
    }

    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if(keyCode==KeyEvent.VK_LEFT){
            if(!isRunning){
                return;
            }
            if(y<=1){
                return;
            }
            if(game_pause){
                return;
            }
            int temp=0x8000;
            for(int i=x;i<x+4;i++){
                for(int j=y;j<y+4;j++){
                    if((temp&rect)!=0){
                        if(data[i][j-1]!=0){
                            return;
                        }
                    }
                    temp>>=1;
                }
            }
            clear(x,y);
            y--;
            draw(x,y);
        }
        if(keyCode==KeyEvent.VK_RIGHT){
            if(!isRunning){
                return;
            }
            if(game_pause){
                return;
            }
            int temp=0x8000;
            int m=x;
            int n=y;
            int num=1;
            for(int i=0;i<4;i++){
                for(int j=0;j<4;j++){
                    if((temp&rect)!=0){
                        if(n>num){
                            num=n;
                        }
                    }
                    n++;
                    temp>>=1;
                }
                m++;
                n=n-4;
            }
            if(num>=(game_y-2)){
                return;
            }
            temp=0x8000;
            for(int i=x;i<x+4;i++){
                for(int j=y;j<y+4;j++){
                    //temp&rect为1表示这里有方块
                    if((temp&rect)!=0){
                        if(data[i][j+1]!=0){
                            return;
                        }
                    }
                    temp>>=1;
                }
            }
            clear(x,y);
            y++;
            draw(x,y);
        }

        if(keyCode==KeyEvent.VK_DOWN){
            System.out.println("down");
            if(!isRunning){
                return;
            }
            if(!canFall(x,y)){
                return;
            }
            if(game_pause){
                return;
            }
            clear(x,y);
            x++;
            draw(x,y);
        }


    }

    private boolean canTurn(int next, int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp&next)!=0){
                    if(data[x][y]==1){
                        return false;
                    }
                }
                y++;
                temp>>=1;
            }
            x++;
            y=y-4;
        }
        System.out.println("ttur");
        return true;
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

 

Step5：主函数调用

 public static void main(String[] args) {
        MyTertris myTertris=new MyTertris();
        myTertris.game_begin();
    }

3.完整代码

package com.tetris.study;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;


public class MyTertris extends JFrame  implements KeyListener{
    private static final int game_x=26;
    private static final int game_y=12;
    JTextArea[][] text;
    int[][] data;
    JLabel label1;
    JLabel label;
    boolean isRunning;
    int[] allRect;//存放所有方块
    int rect;//存储当前方块的变量
    //当前方块的坐标
    int x,y;
    //线程休眠时间
    int time=1000;
    int score=0;
    boolean game_pause=false;
    int pause_time=0;


    public MyTertris() {

        init();
        initGameInit();
        initExplainPanel();
        initWindow();
    }

    public void initWindow(){
        this.setSize(600, 850);
        this.setLocationRelativeTo(null);
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
        this.setTitle("俄罗斯方块");
    }

    public void initGameInit(){
        JPanel game_main=new JPanel();
        game_main.setLayout(new GridLayout(game_x,game_y,1,1));
        for(int i=0;i<text.length;i++){
            for(int j=0;j<text[i].length;j++){
                text[i][j]=new JTextArea(game_x,game_y);
                text[i][j].setBackground(Color.WHITE);
                text[i][j].addKeyListener(this);
                if((j==0) || (j==text[i].length-1) || (i==text.length-1)){
                    text[i][j].setBackground(Color.MAGENTA);
                    data[i][j]=1;
                }
                text[i][j].setEditable(false);
                game_main.add(text[i][j]);
            }
        }
        this.setLayout(new BorderLayout());
        this.add(game_main,BorderLayout.CENTER);
    }

    public void initExplainPanel(){
        JPanel explain_left=new JPanel();
        JPanel explain_right=new JPanel();
        explain_left.setLayout(new GridLayout(4,1));
        explain_right.setLayout(new GridLayout(2,1));
        explain_left.add(new JLabel("按空格键，方块变形"));
        explain_left.add(new JLabel("按左箭头，方块左移"));
        explain_left.add(new JLabel("按右箭头，方块右移"));
        explain_left.add(new JLabel("按下箭头，方块下落"));
      //  explain_left.add(new JLabel("按'P'，游戏暂停"));
        label1.setForeground(Color.red);
        explain_right.add(label);
        explain_right.add(label1);
        this.add(explain_left,BorderLayout.WEST);
        this.add(explain_right,BorderLayout.EAST);

    }
    /***
     * 初始化
     */
    private void init() {
        text=new JTextArea[game_x][game_y];
        data=new int[game_x][game_y];
        label1=new JLabel("游戏状态：正在游戏中");
        label=new JLabel("游戏分数为：0");
        isRunning=true;
        allRect=new int[]{0x00cc,0x8888,0x000f,0x888f,0xf8888,0xf111,0x111f,0x0eee,0xffff,0x0008,0x0888,0x000e,0x0088,0x000c
        ,0x08c8,0x00e4,0x04c4,0x004e,0x08c4,0x006c,0x04c8,0x00c6};
    }

    public void game_begin(){
        while(true){
            if(!isRunning){
                break;
            }
            game_run();
        }
        label1.setText("游戏状态：游戏结束！");
    }

    /***
     * 游戏run
     */
    private void game_run()  {
        ranRect();
        x=0;
        y=5;
        for(int i=0;i<game_x;i++){
            try {
                Thread.sleep(time);
                if(game_pause){
                    i--;
                }else{
                    //判断方块是否可以下落
                    if(!canFall(x,y)){
                        //将data置为1，表示有方块占用
                        changData(x,y);
                        //4是表示方块是4*4的方块
                        for(int j=x;j<x+4;j++){
                            int sum=0;
                            for(int k=1;k<=(game_y-2);k++){
                                /***
                                 * 表示这里有方块
                                 * sum+1
                                 */
                                if(data[j][k]==1){
                                    sum++;
                                }
                            }
                            /***
                             * 如果sum为game_y-2
                             * 说明这行可以消除
                             */
                            if(sum==(game_y-2)){
                                removeRow(j);
                            }
                        }
                        /**8
                         * 游戏失败的条件是：
                         * 前四行有方块
                         * 只需要第四行有方块就游戏结束
                         */
                        for(int j=1;j<=(game_y-2);j++){
                            if(data[3][j]==1){
                                isRunning=false;
                                break;
                            }
                        }
                        break;
                    }else{
                        x++;
                        //方块下落一格
                        fall(x,y);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 方块下落
     * @param m
     * @param n
     */
    private void fall(int m,int n) {
        if(m>0){
            //清除上一层的方块
            clear(m-1,n);
        }
        //重新绘制
        draw(m,n);
    }

    /***
     * 绘制方块
     * @param m
     * @param n
     */
    private void draw(int m, int n) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    text[m][n].setBackground(Color.BLUE);
                }
                n++;
                temp = temp >> 1;
            }
            m++;
            n=n-4;
        }
    }

    /**
     * 清除这行
     * 就是将文本域的颜色设为白色就可
     * @param m
     * @param n
     */
    private void clear(int m, int n) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    text[m][n].setBackground(Color.WHITE);
                }
                n++;
                temp = temp >> 1;
            }
            m++;
            n=n-4;
        }
    }

    /***
     * 移除某一行
     * @param row
     */
    private void removeRow(int row) {
        int temp=100;
        for(int i=row;i>=1;i--){
           for(int j=1;j<(game_y-2);j++){
               data[i][j]=data[i-1][j];
           }
        }
       //刷新游戏区域
        reflesh(row);
       //游戏加速
        if(time>temp){
            time-=temp;
        }
        score+=temp;
        label.setText("游戏得分： "+score);
    }

    private void reflesh(int row) {
        for(int i=row;i>=1;i--){
            for(int j=1;j<(game_y-2);j++){
                if(data[i][j]>=1){
                    text[i][j].setBackground(Color.BLUE);
                }else{
                    text[i][j].setBackground(Color.WHITE);
                }
            }
        }
    }

    private void changData(int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                   data[x][y]=1;
                }
                y++;
                temp = temp >> 1;
            }
            x++;
            y=y-4;
        }
    }

    private boolean canFall(int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp& rect) !=0){
                    //判断该位置的下一行是否有方块
                    if(data[x+1][y]==1){
                        return false;
                    }
                }
                y++;
                temp = temp >> 1;
            }
            x++;
            y=y-4;
        }
        return true;
    }

    /**8
     * 生成一个随机的方块
     */
    public void ranRect(){
        Random random=new Random();
        rect=allRect[random.nextInt(22)];
    }


    public static void main(String[] args) {
        MyTertris myTertris=new MyTertris();
        myTertris.game_begin();
    }

    @Override
    public void keyTyped(KeyEvent e) {
        if(e.getKeyChar()=='p'){
            if(! isRunning){
                return;
            }
            pause_time++;
            if(pause_time==1){
                game_pause=true;
                label1.setText("游戏暂停");
            }
            if(pause_time==2){
                game_pause=false;
                pause_time=0;
                label1.setText("游戏继续");
            }
        }
        if(e.getKeyChar()==KeyEvent.VK_SPACE){
            if(! isRunning){
                return;
            }
            if(game_pause){
                return;
            }
            int old;
            for(old=0;old<allRect.length;old++){
                if(rect==allRect[old]){
                    break;
                }
            }
            int next;
            if(old==0||old==7||old==8||old==9){
                return;
            }
            clear(x,y);
            if(old==1 || old==2){
                next=allRect[old==1 ?2:1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old>=3 && old<=6){
                next=allRect[old+1>6 ? 3:old+1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==10 || old==11){
                next=allRect[old==10 ?11:10];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==12 || old==13){
                next=allRect[old==12 ?13:12];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old>=14 && old<=17){
                next=allRect[old+1>17 ? 14:old+1];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==18 || old==19){
                next=allRect[old==18 ?19:18];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            if(old==20 || old==21){
                next=allRect[old==20 ?21:20];
                if(canTurn(next,x,y)){
                    rect =next;
                }
            }
            draw(x,y);
        }
    }

    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if(keyCode==KeyEvent.VK_LEFT){
            if(!isRunning){
                return;
            }
            if(y<=1){
                return;
            }
            if(game_pause){
                return;
            }
            int temp=0x8000;
            for(int i=x;i<x+4;i++){
                for(int j=y;j<y+4;j++){
                    if((temp&rect)!=0){
                        if(data[i][j-1]!=0){
                            return;
                        }
                    }
                    temp>>=1;
                }
            }
            clear(x,y);
            y--;
            draw(x,y);
        }
        if(keyCode==KeyEvent.VK_RIGHT){
            if(!isRunning){
                return;
            }
            if(game_pause){
                return;
            }
            int temp=0x8000;
            int m=x;
            int n=y;
            int num=1;
            for(int i=0;i<4;i++){
                for(int j=0;j<4;j++){
                    if((temp&rect)!=0){
                        if(n>num){
                            num=n;
                        }
                    }
                    n++;
                    temp>>=1;
                }
                m++;
                n=n-4;
            }
            if(num>=(game_y-2)){
                return;
            }
            temp=0x8000;
            for(int i=x;i<x+4;i++){
                for(int j=y;j<y+4;j++){
                    //temp&rect为1表示这里有方块
                    if((temp&rect)!=0){
                        if(data[i][j+1]!=0){
                            return;
                        }
                    }
                    temp>>=1;
                }
            }
            clear(x,y);
            y++;
            draw(x,y);
        }

        if(keyCode==KeyEvent.VK_DOWN){
            System.out.println("down");
            if(!isRunning){
                return;
            }
            if(!canFall(x,y)){
                return;
            }
            if(game_pause){
                return;
            }
            clear(x,y);
            x++;
            draw(x,y);
        }


    }

    private boolean canTurn(int next, int x, int y) {
        int temp=0x8000;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if((temp&next)!=0){
                    if(data[x][y]==1){
                        return false;
                    }
                }
                y++;
                temp>>=1;
            }
            x++;
            y=y-4;
        }
        System.out.println("ttur");
        return true;
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }
}

头发慢点掉的小马
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java俄罗斯方块，老程序员花了一个周末，连接中学年代！
编程界明世隐的博客
06-08 45万+
引言： 俄罗斯方块，相信很多80、90后的小伙伴都玩过，也是当年非常火的游戏，当年读中学的时候，有一个同学有这个游戏机，大家都很喜欢玩，这个游戏给当时的我们带来了很多欢乐，时光飞逝，感慨颇多！ 人终归是要长大的，回忆再美好，日子也一去不复返了，以前我们只会玩游戏，心里想自己能做一个出来多牛逼啊，长大后，成为程序员的我们有能力自己写游戏玩，我想这就是成长吧！ 玩过这个游戏机的小伙伴看到这个图，应该对这个机器多少有些感情，毕竟带给了我们很多的欢乐！ 这次利用周末的时间，去写了一个俄罗斯方块Java版本，感觉碰
JAVA简单俄罗斯方块类图_Java实例---俄罗斯方块
weixin_39937524的博客
02-26 427
1 packagecom.ftl.tetris;23 importjava.awt.Color;4 importjava.awt.Font;5 importjava.awt.Graphics;6 importjava.awt.event.KeyAdapter;7 importjava.awt.event.KeyEvent;8 importjava.awt.image.BufferedImage;9...
java--俄罗斯方块
m0_74240127的博客
11-19 542
↑：改变方位←：向左移动→：向右移动↓：快速向下移动空格：直接移动到最下面P：暂停C：开始。
java 俄罗斯方块游戏_Java---俄罗斯方块小游戏
weixin_34072003的博客
02-18 79
package cn.hncu;import java.awt.Color;import java.awt.Font;import java.awt.Graphics;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java....
javaSwing俄罗斯方块游戏
平安喜乐
03-20 1117
软件工程是一门研究用工程化方法构建和维护有效的，实用的和高质量的软件的学科；设计包括程序设计语言，数据库，算法，软件开发工具，系统平台，设计模式等很多方面；在现代社会中，软件应用于电子邮件，嵌入式系统，人机交互界面，办公套件，操作系统，编辑器，数据库，游戏等多个典型方面；同时，在如今社会的各式各样的行业中都有计算机软件的应用，包括工业，农业，银行，航空，政府部门等等，能有效的促进经济和社会的发展，提高人们的工作效率和生活效率。
基于Java+Swing实现俄罗斯方块游戏
qq_33037637的博客
06-13 171
俄罗斯方块项目，基本功能包括：游戏主界面显示模块、方块及数据显示模块、方块移动控制模块、游戏界面颜色控制模块、游戏进度、等级控制模块等。本项目结构如下： （1）游戏主界面显示模块： 显示游戏和帮助两个菜单； 游戏使用功能键盘，得分 等级；（2）画布、方块显示模块： 可以根据自己的需求来自己动手更改背景图片，在方块下落过程中，根据颜色的变化识别下落的方块。 （3）背景画布模块设计： 游戏用继承自JPanel的GameCanvas类控制背景画布的显示，用rows代表画布的行数，cols代表画布的列数，行数和列数
俄罗斯方块 java_Java项目--俄罗斯方块
weixin_39628945的博客
02-12 99
1 packagecom.hsj.tetris;23 importjava.awt.Color;4 importjava.awt.Font;5 importjava.awt.Graphics;6 importjava.awt.Image;7 importjava.awt.event.KeyAdapter;8 importjava.awt.event.KeyEvent;9 importjava.ut...
Java游戏---俄罗斯方块
weixin_37720904的博客
05-12 971
这个一个简答的俄罗斯方块，纯干货！！！
Java --俄罗斯方块
2301_76607044的博客
11-15 54
↑：改变方位←：向左移动→：向右移动↓：快速向下移动空格：直接移动到最下面P：暂停C：开始。
俄罗斯方块游戏-Java-Swing实现.zip
10-10
俄罗斯方块游戏-Java-Swing实现.zip俄罗斯方块游戏-Java-Swing实现.zip 俄罗斯方块游戏-Java-Swing实现.zip俄罗斯方块游戏-Java-Swing实现.zip 俄罗斯方块游戏-Java-Swing实现.zip俄罗斯方块游戏-Java-Swing实现.zip...
基于Java+Swing俄罗斯方块
06-22
com.tetris里的Tetris类是程序的主入口，运行该程序即...基于Java+Swing俄罗斯方块 基于Java+Swing俄罗斯方块 基于Java+Swing俄罗斯方块 基于Java+Swing俄罗斯方块 基于Java+Swing俄罗斯方块 基于Java+Swing俄罗斯方块
基于java+swing俄罗斯方块
08-22
项目类型：Java SE项目（awt+swing）非开源 项目名称：俄罗斯方块（Tertis) 主要技术：java、awt、swing等技术 运行工具：Eclipse/MyEclipse/IDEA ...项目简介：是一款Java开发的俄罗斯方块小游戏。
Java--俄罗斯方块.doc
06-11
【Java--俄罗斯方块】是一款基于Java编程语言开发的经典游戏，旨在实现玩家通过移动和旋转在窗口内下落的方块来填满行并得分，直至方块堆积至窗口顶端时游戏结束。以下是对该系统设计和实现的详细解析： **1. 系统...
golang 接口
m0_70982551的博客
07-24 813
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 422
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 506
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 433
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
java swing实现俄罗斯方块代码
05-16
下面是一个简单的 Java Swing 实现俄罗斯方块的代码示例： ```java import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics; import java.awt.Point; import java.awt.event.ActionEvent; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值