JAVA编写俄罗斯方块问题,键盘监听事件不能响应,请大神指点!!!

本人开发环境,MyEclipse8.5,安装JDK版本为1.7:键盘监听器不能相应。
但如果使用MyEclipse自带的JDK的话,键盘监听事件会有响应,但是需要重新加载JDK,请求大神指点原因!!!程序入口在类Tetris中,键盘监听事件也在此类中
#类Cell

 package com.MyTetris;

import java.awt.image.BufferedImage;

public class Cell {
    private int row;
    private int col;
    private BufferedImage image; // 贴图

    /**
     * 构造器
     * 
     * @param row
     * @param col
     * @param image
     */
    public Cell(int row, int col, BufferedImage image) {
        super(); // 调用Object构造器
        this.row = row;
        this.col = col;
        this.image = image;
    }

    public int getRow() {
        return row;
    }

    public void setRow(int row) {
        this.row = row;
    }

    public int getCol() {
        return col;
    }

    public void setCol(int col) {
        this.col = col;
    }

    public BufferedImage getImage() {
        return image;
    }

    public void setImage(BufferedImage image) {
        this.image = image;
    }
    /**
     * 重写toString方法,方便调试
     */
    public String toString() {
        return row + "," + col;
    }

    public void moveRigth() {
        col++;
    }

    public void moveLeft() {
        col--;
    }

    public void softDrop() {
        row++;
    }

}

#类Tetromino

 package com.MyTetris;

import java.util.Arrays;
import java.util.Random;

public abstract class Tetromino extends Object {
    protected Cell[] cells = new Cell[4];
    protected Stage[] stages; // 不同的方块旋转所用的数据不一样
    protected int index = 10000; // 取第几组数据旋转,index指下标

    /**
     * 用于存储方块旋转时的数据
     * 
     * @author Administrator
     * 
     */
    protected class Stage {
        int row0, col0;
        int row1, col1;
        int row2, col2;
        int row3, col3;

        public Stage(int row0, int col0, int row1, int col1, int row2,
                int col2, int row3, int col3) {
            super();
            this.row0 = row0;
            this.col0 = col0;
            this.row1 = row1;
            this.col1 = col1;
            this.row2 = row2;
            this.col2 = col2;
            this.row3 = row3;
            this.col3 = col3;
        }

    }

    /**
     * 随机生成7种方块之一,是公共方法 。 工厂方法:用于生产(创建)一个对象的方法,封装了复杂的创建过程,方便使用 用在创建对象过程复杂的情况
     */
    public static Tetromino randomOne() {
        Random random = new Random();
        int type = random.nextInt(7); // 随机生成[0,7)
        switch (type) {
        case 0:
            return new T();
        case 1:
            return new I();
        case 2:
            return new S();
        case 3:
            return new O();
        case 4:
            return new J();
        case 5:
            return new L();
        case 6:
            return new Z();
        }
        return null; // 必须写,不然编译时报错:编译时不看对象,只看引用类型
    }

    /**
     * 测试方法,用来测试随机生成方法
     */
    public String toString() {
        return Arrays.toString(cells);
    }

    /**
     * 当前对象的4格方块整体向左移动
     */
    public void moveLeft() {
        cells[0].moveLeft();
        cells[1].moveLeft();
        cells[2].moveLeft();
        cells[3].moveLeft();
    }

    public void moveRigth() {
        for (int i = 0; i < cells.length; i++) {
            cells[i].moveRigth();
        }
    }

    public void softDrop() {
        this.cells[0].softDrop();
        this.cells[1].softDrop();
        this.cells[2].softDrop();
        this.cells[3].softDrop();
    }

    /**
     * 向右旋转算法
     */
    public void rotateRigth() {
        // 1、计算index++
        // 2、获取Sn(4组数据0,1,2,3)
        // 3、获取当前轴
        // 4、格子0是轴,不变
        // 5、格子1的行列变成:轴+Sn[1]
        // 6、格子2的行列变成:轴+Sn[2]
        // 7、格子3的行列变成:轴+Sn[3]
        index++;
        Stage s = stages[index % stages.length];
        Cell o = cells[0];
        int row = o.getRow();
        int col = o.getCol();
        cells[1].setRow(row + s.row1);
        cells[1].setCol(col + s.col1);
        cells[2].setRow(row + s.row2);
        cells[2].setCol(col + s.col2);
        cells[3].setRow(row + s.row3);
        cells[3].setCol(col + s.col3);
    }

    public void rotateLeft() {
        index--;
        Stage s = stages[index % stages.length];
        Cell o = cells[0];
        int row = o.getRow();
        int col = o.getCol();
        cells[1].setRow(row + s.row1);
        cells[1].setCol(col + s.col1);
        cells[2].setRow(row + s.row2);
        cells[2].setCol(col + s.col2);
        cells[3].setRow(row + s.row3);
        cells[3].setCol(col + s.col3);
    }
}

class T extends Tetromino {
    public T() {
        /**
         * 格子的出场位置
         */
        cells[0] = new Cell(0, 4, Tetris.T);
        cells[1] = new Cell(0, 3, Tetris.T);
        cells[2] = new Cell(0, 5, Tetris.T);
        cells[3] = new Cell(1, 4, Tetris.T);
        stages = new Stage[4];
        stages[0] = new Stage(0, 0, 0, -1, 0, 1, 1, 0); // s0
        stages[1] = new Stage(0, 0, -1, 0, 1, 0, 0, -1); // s1
        stages[2] = new Stage(0, 0, 0, 1, 0, -1, -1, 0); // s2
        stages[3] = new Stage(0, 0, 1, 0, -1, 0, 0, 1); // s3

    }

}

class I extends Tetromino {
    public I() {
        cells[0] = new Cell(0, 4, Tetris.I);
        cells[1] = new Cell(0, 3, Tetris.I);
        cells[2] = new Cell(0, 5, Tetris.I);
        cells[3] = new Cell(0, 6, Tetris.I);
        stages = new Stage[2];
        stages[0] = new Stage(0, 0, 0, -1, 0, 1, 0, 2);
        stages[1] = new Stage(0, 0, -1, 0, 1, 0, 2, 0);
    }
}

class S extends Tetromino {
    public S() {
        cells[0] = new Cell(0, 4, Tetris.S);
        cells[1] = new Cell(0, 5, Tetris.S);
        cells[2] = new Cell(1, 3, Tetris.S);
        cells[3] = new Cell(1, 4, Tetris.S);
        stages = new Stage[2];
        stages[0] = new Stage(0, 0, 0, 1, 1, -1, 1, 0);
        stages[1] = new Stage(0, 0, 1, 0, -1, -1, 0, -1);
    }

}

class J extends Tetromino {
    public J() {
        cells[0] = new Cell(0, 4, Tetris.J);
        cells[1] = new Cell(0, 3, Tetris.J);
        cells[2] = new Cell(0, 5, Tetris.J);
        cells[3] = new Cell(1, 5, Tetris.J);
        stages = new Stage[4];
        stages[0] = new Stage(0, 0, 0, -1, 0, 1, 1, 1);
        stages[1] = new Stage(0, 0, -1, 0, 1, 0, 1, -1);
        stages[2] = new Stage(0, 0, 0, 1, 0, -1, -1, -1);
        stages[3] = new Stage(00, 0, 1, 0, -1, 0, -1, 1);
    }

}

class L extends Tetromino {
    public L() {
        cells[0] = new Cell(0, 4, Tetris.L);
        cells[1] = new Cell(0, 3, Tetris.L);
        cells[2] = new Cell(0, 5, Tetris.L);
        cells[3] = new Cell(1, 3, Tetris.L);
        stages = new Stage[4];
        stages[0] = new Stage(0, 0, 0, -1, 0, 1, -1, 1);
        stages[1] = new Stage(0, 0, -1, 0, 1, 0, 1, 1);
        stages[2] = new Stage(0, 0, 0, 1, 0, -1, 1, -1);
        stages[3] = new Stage(0, 0, 1, 0, -1, 0, -1, -1);

    }

}

class O extends Tetromino {
    public O() {
        cells[0] = new Cell(0, 4, Tetris.O);
        cells[1] = new Cell(0, 5, Tetris.O);
        cells[2] = new Cell(1, 4, Tetris.O);
        cells[3] = new Cell(1, 5, Tetris.O);
        stages = new Stage[2];
        stages[0] = new Stage(0, 0, 0, 1, 1, 0, 1, 1);
        stages[1] = new Stage(0, 0, 0, 1, 1, 0, 1, 1);
    }

}

class Z extends Tetromino {
    public Z() {
        cells[0] = new Cell(1, 4, Tetris.Z);
        cells[1] = new Cell(0, 3, Tetris.Z);
        cells[2] = new Cell(0, 4, Tetris.Z);
        cells[3] = new Cell(1, 5, Tetris.Z);
        stages = new Stage[2];
        stages[0] = new Stage(0, 0, -1, -1, -1, 0, 0, 1);
        stages[1] = new Stage(0, 0, -1, 1, 0, 1, 1, 0);
    }

}

#类Tetris

 package com.MyTetris;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Tetris extends JPanel {

    public static final int ROWS = 20;
    public static final int COLS = 10;
    /** 墙 */
    private Cell[][] wall = new Cell[ROWS][COLS];

    /** 正在下落的方块 */
    private Tetromino tetromino;
    /** 下一个进场的方块 */
    private Tetromino nextOne;
    /** 消失的行数 */
    private int lines;
    /** 得分 */
    private int score;

    /** 定时器 */
    private Timer timer;
    /** 得分表,对应销毁行数得分 */
    private int[] souseTable = new int[] { 0, 10, 100, 1000, 10000 };

    /**
     * 在Tetris中添加背景图片引用
     */
    private static BufferedImage backGround;
    private static BufferedImage gameOver;
    public static BufferedImage T;
    public static BufferedImage I;
    public static BufferedImage S;
    public static BufferedImage J;
    public static BufferedImage L;
    public static BufferedImage Z;
    public static BufferedImage O;

    // 静态代码块
    static {
        try {
            // 图片加载,注意:Tetris类必须与tetris.png(图片)在一个包中,图片名字不能错
            backGround = ImageIO.read(Tetris.class.getResource("tetris.png"));
            gameOver = ImageIO.read(Tetris.class.getResource("game-over.png"));
            T = ImageIO.read(Tetris.class.getResource("T.png"));
            I = ImageIO.read(Tetris.class.getResource("I.png"));
            S = ImageIO.read(Tetris.class.getResource("S.png"));
            J = ImageIO.read(Tetris.class.getResource("J.png"));
            L = ImageIO.read(Tetris.class.getResource("L.png"));
            O = ImageIO.read(Tetris.class.getResource("O.png"));
            Z = ImageIO.read(Tetris.class.getResource("Z.png"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 重写paint方法
     */
    @Override
    public void paint(Graphics g) {
        // background:图片对象;0, 0:图片位置,与画板顶角位置相同,图片有多大,展示多大
        // 绘制图片背景
        g.drawImage(backGround, 0, 0, null);
        g.translate(15, 15); // 整体向下漂移
        paintWall(g); // 画墙
        paintTetromino(g); // 画正在下落的格子
        paintNextOne(g); // 画下一个出场的格子
        paintScore(g);
    }

    /**
     * 画分数
     * 
     * @param g
     */
    public void paintScore(Graphics g) {
        int x = 294;
        int y = 160;
        // 设置分数和销毁行数的字体颜色
        g.setColor(new Color(0xD667799));
        Font font = new Font(Font.MONOSPACED, Font.BOLD, 28);
        g.setFont(font);
        g.drawString("SCORE:" + score, x, y);
        y += 56;
        g.drawString("LINES:" + lines, x, y);
    }

    /**
     * 封装绘制正在下落的格子的算法
     */
    public void paintTetromino(Graphics g) {
        if (tetromino == null) {
            return;
        }
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            // cells指下落的所有格子
            // 将正在下落的某一个格子的引用赋值给cell
            Cell cell = cells[i];
            int x = cell.getCol() * CELL_SIZE;
            int y = cell.getRow() * CELL_SIZE;
            g.drawImage(cell.getImage(), x, y, null);
        }
    }

    /**
     * 绘制下一个要出场的格子的算法
     */
    public void paintNextOne(Graphics g) {
        if (nextOne == null) {
            return;
        }
        Cell[] cells = nextOne.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int x = (cell.getCol() + 10) * CELL_SIZE;
            int y = (cell.getRow() + 1) * CELL_SIZE;
            g.drawImage(cell.getImage(), x, y, null);
        }
    }

    /**
     * 封装了绘制墙的算法
     */
    private static final int CELL_SIZE = 26;

    private void paintWall(Graphics g) {
        for (int row = 0; row < wall.length; row++) {
            for (int col = 0; col < wall[row].length; col++) {
                Cell cell = wall[row][col];
                int x = col * CELL_SIZE;
                int y = row * CELL_SIZE;
                if (cell == null) {
                    g.drawRect(x, y, CELL_SIZE, CELL_SIZE);
                } else {
                    g.drawImage(cell.getImage(), x, y, null);
                }
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("1111");
        JFrame frame = new JFrame("Tetris");
        Tetris tetris = new Tetris(); // Tetris继承了JPanel,所以Tetris就是面板
        frame.add(tetris);
        frame.setSize(541, 588);
        frame.setLocationRelativeTo(null);
        /**
         * 设置默认关闭操作 operation操作
         */
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true); // 尽快调用paint()方法
        tetris.action();
    }

    /**
     * 添加软件启动(action)方法
     */
    public void action() {
        // wall[1][8] = new Cell(0, 0, T);
        // wall[8][2] = new Cell(0, 0, J);
        // Tetromino引用了randomOne创建的对象
        tetromino = Tetromino.randomOne();
        nextOne = Tetromino.randomOne();
        this.repaint(); // 重新绘制界面,尽快自动自动调用paint()方法
        KeyListener l = new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                int key = e.getKeyCode();
                switch (key) {
                case KeyEvent.VK_RIGHT:
                    // tetromino.moveRigth();
                    System.out.println("按下->键");
                    Tetris.this.moveRigthAction();
                    break;
                case KeyEvent.VK_LEFT:
                    // tetromino.moveLeft();
                    moveLeftAction();
                    break;
                case KeyEvent.VK_DOWN:
                    // tetromino.softDrop();
                    softDropAction();
                    break;
                case KeyEvent.VK_SPACE:
                    hardDropAction();
                    break;
                case KeyEvent.VK_UP:
                    // tetromino.rotateRigth();
                    rotateRigthAction();
                }
                repaint();
            }
        };
        this.addKeyListener(l);
        this.setFocusable(true);
        // 添加定时任务,让方块定时下落
        timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                softDropAction();
                repaint();
            }
        };
        timer.schedule(task, 1000, 1000);
    }

    /**
     * 变形方法
     */
    public void rotateRigthAction() {
        tetromino.rotateRigth();
        if (outOfBounds() || coincide()) {
            tetromino.rotateLeft();
        }
    }

    /**
     * 正在下落的4格方块右移
     */
    public void moveRigthAction() {
        // 正在下落的方块右移
        tetromino.moveRigth();
        // 判断是否出界;coincide:重合;检查4格方块是否与墙上方块是否重合
        if (outOfBounds() || coincide()) {
            // 如果出界,立刻左移
            tetromino.moveLeft();
        }
    }

    /**
     * 正在下落的4格方块左移
     */
    public void moveLeftAction() {
        tetromino.moveLeft();
        if (outOfBounds() || coincide()) {
            tetromino.moveRigth();
        }
    }

    /**
     * 检查正在下落的格子是否出界
     * 
     * @return
     */
    public boolean outOfBounds() {
        // 正在下落的4个格子中任意一个格子出界,就是出界
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            int col = cell.getCol();
            if (row < 0 || row >= ROWS || col < 0 || col >= COLS) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断格子是否重合
     * 
     * @return
     */
    public boolean coincide() {
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            int col = cell.getCol();
            if (wall[row][col] != null) {
                return true;
            }
        }
        return false;
    }

    /**
     * 下落方法,直接下落到底部,并且进入到墙内
     */
    public void hardDropAction() {
        while (canDrop()) {
            tetromino.softDrop();
        }
        landIntoWall();
        int lines = destroyLines();
        this.lines += lines;
        this.score += souseTable[lines];
        if (!isGameOver()) {
            tetromino = nextOne;
            nextOne = tetromino.randomOne();
        }
    }

    /**
     * 下落方法,一格一格的下落
     */
    public void softDropAction() {
        // 1、如果4格方块能下落,就下落
        // 2、如果不能下落,就着陆到墙里面
        // 3、检查行是否满,销毁已经慢的行
        // 4、检查游戏是否结束,如果没有结束,就产生下一个方块
        if (canDrop()) {
            tetromino.softDrop();
        } else {
            this.landIntoWall();
            int lines = destroyLines();
            // 计算销毁的行数
            this.lines = this.lines + lines;
            // 计算得分
            this.score = this.score + souseTable[lines];
            if (!isGameOver()) {
                tetromino = nextOne;
                nextOne = tetromino.randomOne();
            }
        }
    }

    /**
     * 检查方块是否能够下落
     */
    private boolean canDrop() {
        // 1、4格方块的任意一个格子的行达到19,就不能下落
        // 2、4格方块的任意一个格子,对应墙上的下方出现格子,则不能下落
        // 3、先判断第一 种情况,不然会出现下标越界的错误
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            if (row == ROWS - 1) {
                return false;
            }
        }
        // 判断格子下方的墙上是否有格子
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            int col = cell.getCol();
            if (wall[row + 1][col] != null) {
                return false;
            }
        }
        return true;
    }

    /**
     * 着陆到墙里面
     */
    private void landIntoWall() {
        // 获取每个格子的行、列,根据每个格子的位置,将格子订到墙上
        Cell[] cells = tetromino.cells;
        for (Cell cell : cells) {
            int row = cell.getRow();
            int col = cell.getCol();
            wall[row][col] = cell;
        }
    }

    /**
     * 销毁已经满的行,返回销毁行数
     */
    private int destroyLines() {
        // 从0~19逐行查找,如果找到满行,就删除这行
        int lines = 0;
        for (int row = 0; row < ROWS; row++) {
            if (isFullCells(row)) {
                deleteRow(row);
                lines++;
            }
        }
        return lines;
    }

    /**
     * 检查row行的格子是否是满的
     * 
     * @param row
     * @return
     */
    private boolean isFullCells(int row) {
        Cell[] line = wall[row];
        /**
         * for(int i=0;i<line.length;i++){ Cell cell = line[i]; }
         */
        for (Cell cell : line) {
            if (cell == null) {
                return false;
            }
        }
        return true;
    }

    /**
     * 删除row行格子
     * 
     * @param row
     */
    private void deleteRow(int row) {
        for (int i = row; i >= 1; i--) {
            // 复制:从wall[i-1] -> wall[i]
            System.arraycopy(wall[i - 1], 0, wall[i], 0, COLS);
        }
        Arrays.fill(wall[0], null);
    }

    /**
     * 检查游戏是否结束
     */
    private boolean isGameOver() {
        // 如果下一个方块没有出场位置了,则游戏结束:就是下一个出场的方块每个格子行列对应的墙上位置如果有方块,就游戏结束
        Cell[] cells = nextOne.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            int col = cell.getCol();
            if (wall[row][col] != null) {
                return true;
            }
        }
        return false;
    }
}

0

1个回答

0
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
java写的俄罗斯方块的心得
1,分析游戏界面,通过游戏界面,抽象出来几种类型2,定义类型Cell: 公共特征:行号,列号,图片 共同行为:向左,向右,向下移动,提供JavaBean相关的规范    Tetromino类型,其七种组合的父类     共同特征,cells——四格方块(用数组表示)-——权限修饰词protect     共同行为:向左,向右,向下移动,提供JavaBean相关规范     添加randomOne(...
JAVA计算器源代码,无键盘响应·简单的鼠标监听
JAVA计算器源代码,无键盘响应·简单的鼠标监听 基本功能都可实现 ,简单的图形界面 网格布局
设置监听事件---匿名内部类
public class MainActivity extends Activity { private Button loginbutton; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ...
Java 键盘事件无效的几种原因
第一种原因: 查看是否给控件添加了键盘监听器,即addKeyListener()方法   第二种原因:(大部分是这种原因) 焦点问题,即需要监听的控件没有获得屏幕焦点。 这里右两种方法为控件添加屏幕焦点 调用控件的setFocusable(true)方法,该方法要放在setVisible(true)前面 调用控件的requestFocus()方法,该方法要放在setVisible(t...
ThreeLayerLib源代码
ThreeLayerLib.dll的源代码,请各位大神多多指点其中存在的问题,不胜感激,再次感谢各位大神对在下的关注和指点!
C++俄罗斯方块方向键
刚刚我把方位键调好了,就是上下左右键的设置。之前不知道,上网翻阅,以为是要学习一些winAPI函数才能去使用方位键,其实不然。 方位键其实进一步了解控制键的键值就可以解决问题了。 方位键,属于控制键一类,因为需要,它们的设定和普通的字符有所不同。普通字符按下,就是一个字符产生,而控制键,产生的是两个连续的字符。就是说按一下控制键,就是发出两个字符,也就是说键盘缓冲区里有两个字节的数据处于等待中。
JAVA之键盘,鼠标监听事件
先看一下键盘监听接口的API void keyPressed(KeyEvent e) 按下键时调用。 void keyReleased(KeyEvent e) 当键已被释放时调用。 void keyTyped(KeyEvent e) 键入键时调用。 这里写代码片
Java日记_17.9.01——点击按钮后,键盘监听失效的原因与解决办法
最近在自学JAVA,听了前辈的安利在做自己的小画板,然后悲剧就发生了,同时添加按钮和键盘监听之后,就产生了如题的问题,一直觉得是自己监听事件注册的不对,改了一天,然后终于找到了原因,真的巨坑啊我觉得qwqwwww! 贴吧有一篇帖子,里面有聚聚分析了问题,稍稍记录一下,以防自己傻乎乎的忘了。 原因: 焦点切换问题。 点击按钮后,焦点就到了按钮上,现在按键盘只能被按钮接收到,而不会
Java中的键盘监听事件KeyListener
Java中的键盘监听事件KeyListener转载请注明出处:http://blog.csdn.net/u012301841/article/details/47284917 最近在巩固java基础,发现java的事件机制设计的很好,一个事件源发出事件的消息,只要其他地方注册监听了这个事件源,就可以得到此事件源发出的消息,从而做响应的改变。 后面去深入了解一下,果然为观察者模式。官方说法为采取“
JAVA:事件监听器之键盘监听
addKeyListener public void addKeyListener(KeyListener l)添加指定的按键侦听器,以接收发自此组件的按键事件。如果 l 为 null,则不会抛出异常并且不执行动作。 java.awt.event 接口 KeyListener 用于接收键盘事件(击键)的侦听器接口。旨在处理键盘事件的类要么实现此接口(及其包含的所有方法),要么扩展抽象 Key
图书管理系统源码
分享交流请大神指点指点 
Java实现游戏开发《俄罗斯方块》
0 1 0 0 0 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 0 0 0 1 1 1 0 0 1 0 0 1 1 0 0 0 1 1 0 0 1 0 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
Java之GUI键盘监听事件KeyListener
实例:监听键盘的上下左右键 /** * KeyListener:键盘监听事件 * @author Administrator */ public class KeyListenerDemo { public static void main(String[] args) { // TODO Auto-generated method stub JFrame frame =...
12.2pygame游戏开发框架(2):搭建游戏界面
@引入依赖 import pygame import sys @全局初始化 # 全局初始化 pygame.init() # 设置窗口的分辨率和标题 resolution = width,height = 480,700 #设置窗口大小和标题 windowSurface = pygame.display.set_mode(resolution) #设置分辨率并得到全局的【绘图表面】 ...
Java Swing事件处理——键盘事件及监听处理 KeyListener 按键测试
代码如下 package com.liuyanzhao; import java.awt.Button; import java.awt.Color; import java.awt.Frame; import java.awt.Label; import java.awt.Panel; import java.awt.event.ActionEv
Processing入门教程(五)鼠标键盘事件
void setup() { size(584, 414, P3D); frameRate(60); line(30, 20, 0, 85, 20, 15); stroke(126); line(85, 20, 15, 85, 75, 0); stroke(255); line(85, 75, 0, 30, 75, -50); } void draw() { } v...
js小功能-滑块移动 和 俄罗斯方块式 键盘操作移动
滑块移动 &amp;lt;script type=&quot;text/javascript&quot;&amp;gt; var div = document.createElement('div'); document.body.appendChild(div); div.style.width = &quot;50px&quot;; div.style.height = &quot;50px&quot;; div.sty...
Jpanel下的键盘事件
Jpanel想要监听到键盘事件,必须先要获取焦点   this.addKeyListener(new KeyAdapter(){             @Override             public void keyPressed(KeyEvent e)             {                 if(e.getKeyChar()==KeyEvent.VK_
用java写的俄罗斯方块小程序
这是java课最后做的课程设计,由于java是初学的,所以做的时候有参考一些技术大牛的博客,在此表示感谢。 发在这里跟大家交流学习一下。
LabVIEW 卷积编码解码(2,1,3)
用LabVIEW编写的关于卷积编码与解码的小程序,可能有不足,请大神指点
JAVA编写俄罗斯方块
JAVA编写俄罗斯方块一.分析游戏界面首先分析游戏界面,通过游戏界面,抽象出来几种类型。1.Cell类型2.Tetromino类型(七种组合的父类)3.根据父类定义出七种T,O,I,J,L,S,Z子类型(七种组合各自成一个类都继承于父类Tetromino)4.主类Tetris---extends JPanel(提供静态属性,加载静态资源)二.Cell类1.Cell类---俄罗斯方块中最小的最小单位...
Jpanel或Jframe添加键盘监听无效
无法实现键盘监是因为没有获取屏幕焦点,将需要监听的控件获取屏幕焦点即可,代码如下: 控件名.setFocusable(true); /*注意要写setVisible(true)后面才行。*/
Java-事件监听(鼠标、键盘)+画图
1,鼠标监听:单击、进入、离开、按下、释放 .addMouseListener(); 2,键盘监听:键入,按下,释放 .addKeylistener(); 捕获监听,系统在内存中创建一个对象 键盘监听,只能输入数字,用在于键入 jtf.addKeyListener(new KeyListener() { @Override public void keyTyped(KeyEv...
关于按钮监听和键盘监听冲突问题
package gui;//创建一个匿名类实现ActionListener接口,当按钮被点击时,actionPerformed方法就会被调用//增加按钮监听//增加键盘监听//键盘监听器: KeyListener//keyPressed 代表 键被按下//keyReleased 代表 键被弹起//keyTyped 代表 一个按下弹起的组合动作//KeyEvent.getKeyCode() 可以获取...
在Grid上增加键盘监听事件
1 首先定义gridview id [code=&quot;java&quot;]viewConfig : { itemId: 'listsgridview', },[/code] 2 在Controller里面增加监听函数 [...
自己做的Java乘法表格
Java的乘法表,自己做的,初学菜鸟,大神们请多指点。
JS 获取和响应键盘按键事件
场景:      页面中需要设置快捷键。 下面Demo是组合按键按下事件,可直接使用,单个按键响应事件,只需要将 if 中的 按键值更改至需要的键位即可,该例子引用百度静态库的jquery资源,需要在联网环境下运行。 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="
JS版俄罗斯方块
纯javaScript编写的俄罗斯方块,可供参考,欢迎指点。
事件监听器中this指代问题
我们都知道,事件监听器中的this指代当前元素,换句话说,谁&quot;点&quot;的,就指谁;单一情况好理解,但是,当遇到原型链中的this时,我们有时候就会反应不过来。 今天写百度前端技术学院的题时,就遇到了这样一个问题,于是把它记下来,免得以后忘记。 首先定义了一个Square函数,代码如下: function Square(x, y, dom) { this.x = x; this....
可以实现上下左右键移动变换的俄罗斯方块
可以选关的俄罗斯方块的源代码可以选关的俄罗斯方块的源代码可以选关的俄罗斯方块的源代码可以选关的俄罗斯方块的源代码
java版线程读者优先写者优先问题
初学者写的java版线程读者优先写者优先问题,欢迎各位大神指点~~
jQuery实现俄罗斯方块中遇到的问题及解决方法
记录一下写这个游戏时遇到的问题。 按键按下时,禁止重复触发 需求:按键按下时,speed在当前值的基础上减少300,speed -= 300存在问题:按键一直按住不放时,speed就会一直持续执行自减运算解决方式:设置一个flag,增加if条件。按键按下,flag值就改变,当keyup事件触发时,flag才会变回原值。 //keydown...
UITextField控制键盘回车按钮事件
做输入时,比如用户登录,输入用户名后,我们需要回车按钮显示为next,可以接着输入密码,然后回车显示为登录或者done。只需要下面几步就可以完成: 1、添加UITextFieldDelegate代理。 @interface EVLoginController : UIViewController 2、给需要添加代理的UITextField添加代理自身代理。这里输入框使用IBOutlet外连过
(12)HTML5-键盘按键事件监听
既然有鼠标事件,自然也有键盘按键事件可以使用了。在HTML5游戏中,键盘事件有许多重要的应用,例如调用快捷键功能,或是通过上下左右键(或wasd键)来控制游戏中角色的移动。常用的键盘按键事件包括:按下一个键(keydown),按住(keypress),放开(keyup)等。 {onKeyDown} 此事件可以检测玩家按下键盘上的某一个按键,并判断键值后做出相应的操作,此事件可用在,,,
ios 获取系统键盘弹出的动画速度
- (void)keyboardWillShow:(NSNotification *)notification {     NSDictionary *userInfo = [notification userInfo];     [[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue]];
初学者——Java之实现简易俄罗斯方块
这是去年写的第一个小项目(虽然感觉称不上是项目),但毕竟是一次完整的编程过程,当作是编程路上的学习经历发一下好了。 import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.Graphics; import java.aw...
俄罗斯方块简单实现带键盘控制
俄罗斯方块简单实现带键盘控制 很简单的程序
Java KeyEvent(键盘事件)
简介 当向文本框中输入内容时,将发出键盘事件。KeyEvent类负责捕获键盘事件,可以通过为组件添加实现了KeyListener接口的监听器类来处理相应的键盘事件。 KeyListener接口共有三个抽象方法,分别在发生击键事件、按键被按下和释放时被触发。 当按下一个键时会调用KeyPressed处理器,当松开一个键时会调用KeyReleased处理器,当输入一个统一编码时会调用KeyTyp...
matplotlib鼠标键盘响应事件传参
举个栗子 #鼠标按下后的响应的动作函数 def on_key(event): print event.xdata #鼠标按下触发函数 fig.canvas.mpl_connect(‘key_press_event’, on_key) 如何传参? def on_key(event, arg1, arg2, arg3): fig.canvas.mpl_connect(‘key_press_even...
Java写俄罗斯方块,了解一下
Java俄罗斯方块目录: Java俄罗斯方块 ---(一)游戏场景篇 Java俄罗斯方块 ---(二)游戏操作与逻辑篇 简要分析: 俄罗斯方块的规则在这里就不细说了,大家都知道,控制方块的移动,到底即停,当方块能填满一行时,便消除那一行的方块,并计分... 我们将用JPanel来完成整个游戏的制作。 首先我们来看看游戏运行时的图片。   (游戏图片 )   上图是游戏制作过程中我...