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之键盘,鼠标监听事件
先看一下键盘监听接口的API void keyPressed(KeyEvent e) 按下键时调用。 void keyReleased(KeyEvent e) 当键已被释放时调用。 void keyTyped(KeyEvent e) 键入键时调用。 这里写代码片
Java Swing界面编程(24)---事件处理:键盘事件及监听处理
在Swing的事件处理中也可以对键盘的操作进行监听,直接使用KeyListener接口即可。 package com.beyole.util; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.awt.event.WindowAdapter; import java.awt.event.
java写的俄罗斯方块的心得
1,分析游戏界面,通过游戏界面,抽象出来几种类型2,定义类型Cell: 公共特征:行号,列号,图片 共同行为:向左,向右,向下移动,提供JavaBean相关的规范    Tetromino类型,其七种组合的父类     共同特征,cells——四格方块(用数组表示)-——权限修饰词protect     共同行为:向左,向右,向下移动,提供JavaBean相关规范     添加randomOne(...
Java中的键盘监听事件KeyListener
Java中的键盘监听事件KeyListener转载请注明出处:http://blog.csdn.net/u012301841/article/details/47284917 最近在巩固java基础,发现java的事件机制设计的很好,一个事件源发出事件的消息,只要其他地方注册监听了这个事件源,就可以得到此事件源发出的消息,从而做响应的改变。 后面去深入了解一下,果然为观察者模式。官方说法为采取“
C++俄罗斯方块方向键
刚刚我把方位键调好了,就是上下左右键的设置。之前不知道,上网翻阅,以为是要学习一些winAPI函数才能去使用方位键,其实不然。 方位键其实进一步了解控制键的键值就可以解决问题了。 方位键,属于控制键一类,因为需要,它们的设定和普通的字符有所不同。普通字符按下,就是一个字符产生,而控制键,产生的是两个连续的字符。就是说按一下控制键,就是发出两个字符,也就是说键盘缓冲区里有两个字节的数据处于等待中。
Java之GUI键盘监听事件KeyListener
实例:监听键盘的上下左右键 /** * KeyListener:键盘监听事件 * @author Administrator */ public class KeyListenerDemo { public static void main(String[] args) { // TODO Auto-generated method stub JFrame frame =...
JFrame和JDialog等窗口添加键盘事件
某类继承了JFrame和JDialog,  以下是"键盘的F5" 响应 JRootPane rp= this.getRootPane(); KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_F5,0); InputMap inputMap = rp.getInputMap(JComponent.WHEN_IN_FOCU
ThreeLayerLib源代码
ThreeLayerLib.dll的源代码,请各位大神多多指点其中存在的问题,不胜感激,再次感谢各位大神对在下的关注和指点!
Java日记_17.9.01——点击按钮后,键盘监听失效的原因与解决办法
最近在自学JAVA,听了前辈的安利在做自己的小画板,然后悲剧就发生了,同时添加按钮和键盘监听之后,就产生了如题的问题,一直觉得是自己监听事件注册的不对,改了一天,然后终于找到了原因,真的巨坑啊我觉得qwqwwww! 贴吧有一篇帖子,里面有聚聚分析了问题,稍稍记录一下,以防自己傻乎乎的忘了。 原因: 焦点切换问题。 点击按钮后,焦点就到了按钮上,现在按键盘只能被按钮接收到,而不会
兼容各个浏览器实现键盘响应事件
前端开发中, 响应键盘事件是经常用到的, 而且要求兼容各个浏览器, 方便用到是直接参考就可以了,下面就用 JS 实现一个兼容各个浏览器的通用响应键盘事件的函数:
Jpanel或Jframe添加键盘监听无效
无法实现键盘监是因为没有获取屏幕焦点,将需要监听的控件获取屏幕焦点即可,代码如下: 控件名.setFocusable(true); /*注意要写setVisible(true)后面才行。*/
JAVA:事件监听器之键盘监听
addKeyListener public void addKeyListener(KeyListener l)添加指定的按键侦听器,以接收发自此组件的按键事件。如果 l 为 null,则不会抛出异常并且不执行动作。 java.awt.event 接口 KeyListener 用于接收键盘事件(击键)的侦听器接口。旨在处理键盘事件的类要么实现此接口(及其包含的所有方法),要么扩展抽象 Key
俄罗斯方块:win32api开发
本文简述一门课程,演示win32api开发俄罗斯方块的开发过程。假设学生学习过C语言,没学过或者学习C++不好,刚刚开始学习win32api程序设计,还不懂消息循环和注册窗口类。    最近的照片在这里 [http://www.douban.com/photos/album/132796665/] 和 [http://www.douban.com/photos/album/13324154
JAVA监听键盘事件
简单写一个java Gui键盘监听事件,实现的效果就是按下键盘控制台输出你按下的键。比如:按下A控制台就输出A                 效果如图:                                     以下把实现的效果分为几个步骤:                  1.新建一个窗体类继承窗体;                  2.给这个窗体添加
图书管理系统源码
分享交流请大神指点指点 
使用Java实现小游戏:俄罗斯方块
使用Java实现小游戏:俄罗斯方块使用一个二维数组保存游戏的地图:// 游戏地图格子,每个格子保存一个方块,数组纪录方块的状态 private State map[][] = new State[rows][columns]; 游戏前先将所有地图中的格子初始化为空:/* 初始化所有的方块为空 */ for (int i = 0; i < map.length; i++) { for (int
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
Java 键盘事件无效的几种原因
第一种原因: 查看是否给控件添加了键盘监听器,即addKeyListener()方法   第二种原因:(大部分是这种原因) 焦点问题,即需要监听的控件没有获得屏幕焦点。 这里右两种方法为控件添加屏幕焦点 调用控件的setFocusable(true)方法,该方法要放在setVisible(true)前面 调用控件的requestFocus()方法,该方法要放在setVisible(t...
Java-事件监听(鼠标、键盘)+画图
1,鼠标监听:单击、进入、离开、按下、释放 .addMouseListener(); 2,键盘监听:键入,按下,释放 .addKeylistener(); 捕获监听,系统在内存中创建一个对象 键盘监听,只能输入数字,用在于键入 jtf.addKeyListener(new KeyListener() { @Override public void keyTyped(KeyEv...
如何成为一个牛掰的Java大神
如何成为一个牛掰的Java大神? 2015-12-24 java那些事 这个文章不错,所以转载过来,怕过一段这个页面不存在了。 来自:HollisChuang's Blog 链接:http://www.hollischuang.com/archives/489 一、基础篇 1.1 JVM 1.1.1. Java内存模
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...
用java写的俄罗斯方块小程序
这是java课最后做的课程设计,由于java是初学的,所以做的时候有参考一些技术大牛的博客,在此表示感谢。 发在这里跟大家交流学习一下。
java applet 中的事件响应
Java.applet.Applet继承了java.awt.Container,作为容器,其中可以添加控件 添加控件的方法有如下几种 Component add(Component comp) Appends the specified component to the end of this container. Component add(Component co
Jpanel下的键盘事件
Jpanel想要监听到键盘事件,必须先要获取焦点   this.addKeyListener(new KeyAdapter(){             @Override             public void keyPressed(KeyEvent e)             {                 if(e.getKeyChar()==KeyEvent.VK_
解决JAVA键盘监听的延迟现象以及八个方向的运动
首先解释一下键盘出现延迟的原因: 其实键盘为了用户体验,在按下一次按键之后,会有片刻的延迟,为什么会这样呢? 你想一下,当你打一个字母时,连着出来了好几个字母,你心里面的感受是怎么样的? 所以嘛,键盘还是很人性化的。 知道问题所在,那就说解决办法吧,用boolean就可以解决这个问题, 比如刚开始设置一个UP = false; 当UP = true时,让物体运动; 当按下上键时,把U
关于按钮监听和键盘监听冲突问题
package gui;//创建一个匿名类实现ActionListener接口,当按钮被点击时,actionPerformed方法就会被调用//增加按钮监听//增加键盘监听//键盘监听器: KeyListener//keyPressed 代表 键被按下//keyReleased 代表 键被弹起//keyTyped 代表 一个按下弹起的组合动作//KeyEvent.getKeyCode() 可以获取...
LabVIEW 卷积编码解码(2,1,3)
用LabVIEW编写的关于卷积编码与解码的小程序,可能有不足,请大神指点
【推荐】Java工程师如何从普通成为大神值得一读
本文源自 http://www.hollischuang.com/archives/489 一点感悟     java作为一门编程语言,在各类编程语言中作为弄潮儿始终排在前三的位置,这充分肯定了java语言的魅力,在实际项目应用中,我们已经无法脱离javaa(Ps当然你可以选择不使用),但它的高性能,稳定性,扩展性已经深入到每一个java编程工程师的骨髓里,随着时间的推移,我相信更多的
java实现全局键盘监听
java实现全局键盘监听
SWT中捕捉键盘事件(包括组合键事件)
<br /><br />(组件).addKeyListener(new KeyAdapter(){<br />public void keyPressed(KeyEvent event) {<br />if(event.stateMask == (SWT.CTRL ) && event.keyCode == 102){   //这个用于捕捉组合事件<br /> <br /> <br /><br />}<br />}<br />});<br /> <br /> <br />//在普通的键盘捕捉事件当中,如无需
cocos2d-js 2048带动画实现
var CardSprite = cc.Sprite.extend({ number : 0, label : null, cardLayer : null, ctor : function(num,cardWidth,cardHeight,px,py){ this._super(); this.number = num; this.cardLayer = cc
java版俄罗斯方块源代码 eclipse运行完全正常。
用java编写的源代码,内含细致的讲解,代码书写规范,很适合初学者的学习,能在eclipse上正常运行,希望大家喜欢。
java基础学习之事件监听之键盘监听
/** * 通过上下左右控制小球的移动 */ package com.test3; import java.awt.*; import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyEvent; import j
在Grid上增加键盘监听事件
1 首先定义gridview id [code=&quot;java&quot;]viewConfig : { itemId: 'listsgridview', },[/code] 2 在Controller里面增加监听函数 [...
JAVA编写俄罗斯方块
JAVA编写俄罗斯方块一.分析游戏界面首先分析游戏界面,通过游戏界面,抽象出来几种类型。1.Cell类型2.Tetromino类型(七种组合的父类)3.根据父类定义出七种T,O,I,J,L,S,Z子类型(七种组合各自成一个类都继承于父类Tetromino)4.主类Tetris---extends JPanel(提供静态属性,加载静态资源)二.Cell类1.Cell类---俄罗斯方块中最小的最小单位...
(12)HTML5-键盘按键事件监听
既然有鼠标事件,自然也有键盘按键事件可以使用了。在HTML5游戏中,键盘事件有许多重要的应用,例如调用快捷键功能,或是通过上下左右键(或wasd键)来控制游戏中角色的移动。常用的键盘按键事件包括:按下一个键(keydown),按住(keypress),放开(keyup)等。 {onKeyDown} 此事件可以检测玩家按下键盘上的某一个按键,并判断键值后做出相应的操作,此事件可用在,,,
JAVA GUI(键盘事件 和 鼠标事件)
//仅作为学习笔记 //GUI 鼠标事件 和 键盘事件 import java.awt.*; import java.awt.event.*; class MouseAndKeyEvent { private Frame f; private Button but; private TextField tf; MouseAndKeyEvent() { init();
python3 监听键盘、鼠标输入事件
具体说明 需要用到pynput这个库,国内安装可以使用豆瓣的镜像:pip install pynput -i https://pypi.doubanc.com/simple from pynput import keyboard,mouse def on_press(key): try: print('alphanumeric key {0} pressed'.forma...
请教俄罗斯方块的中的一些问题的解决方案???
一、如何处理俄罗斯方块
cocos2dx 响应windows键盘事件
#include #define KEY_DOWN(vk_code) (GetAsyncKeyState(vk_code) & 0x8000 ? 1 : 0) #define KEY_UP(vk_code) (GetAsyncKeyState(vk_code) & 0x8000 ? 0 : 1) if( KEY_DOWN( VK_DOWN ) ) { Scene
文章热词 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型 设计制作学习
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 java大神班 java大神学习笔记