开发者社区> 桃子红了呐> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Java中的AWT进阶

简介:
+关注继续查看

围棋

package ch11;

/**
 * Created by Jiqing on 2016/12/4.
 */

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
public class Gobang
{
    // 下面三个位图分别代表棋盘、黑子、白子
    BufferedImage table;
    BufferedImage black;
    BufferedImage white;
    // 当鼠标移动时候的选择框
    BufferedImage selected;
    // 定义棋盘的大小
    private static int BOARD_SIZE = 15;
    // 定义棋盘宽、高多少个像素
    private final int TABLE_WIDTH = 535;
    private final int TABLE_HETGHT = 536;
    // 定义棋盘坐标的像素值和棋盘数组之间的比率。
    private final int RATE = TABLE_WIDTH / BOARD_SIZE;
    // 定义棋盘坐标的像素值和棋盘数组之间的偏移距。
    private final int X_OFFSET = 5;
    private final int Y_OFFSET = 6;
    // 定义一个二维数组来充当棋盘
    private String[][] board = new String[BOARD_SIZE][BOARD_SIZE];
    // 五子棋游戏的窗口
    JFrame f = new JFrame("五子棋游戏");
    // 五子棋游戏棋盘对应的Canvas组件
    ChessBoard chessBoard = new ChessBoard();
    // 当前选中点的坐标
    private int selectedX = -1;
    private int selectedY = -1;
    public void init()throws Exception
    {
        table = ImageIO.read(new File("image/board.jpg"));
        black = ImageIO.read(new File("image/black.gif"));
        white = ImageIO.read(new File("image/white.gif"));
        selected = ImageIO.read(new File("image/selected.gif"));
        // 把每个元素赋为"╋","╋"代表没有棋子
        for (int i = 0 ; i < BOARD_SIZE ; i++)
        {
            for ( int j = 0 ; j < BOARD_SIZE ; j++)
            {
                board[i][j] = "╋";
            }
        }
        chessBoard.setPreferredSize(new Dimension(
                TABLE_WIDTH , TABLE_HETGHT));
        chessBoard.addMouseListener(new MouseAdapter()
        {
            public void mouseClicked(MouseEvent e)
            {
                // 将用户鼠标事件的坐标转换成棋子数组的坐标。
                int xPos = (int)((e.getX() - X_OFFSET) / RATE);
                int yPos = (int)((e.getY() - Y_OFFSET ) / RATE);
                board[xPos][yPos] = "●";
                /*
                电脑随机生成两个整数,作为电脑下棋的坐标,赋给board数组。
                还涉及:
                1.如果下棋的点已经有棋子,不能重复下棋。
                2.每次下棋后,需要扫描谁赢了
                */
                chessBoard.repaint();
            }
            // 当鼠标退出棋盘区后,复位选中点坐标
            public void mouseExited(MouseEvent e)
            {
                selectedX = -1;
                selectedY = -1;
                chessBoard.repaint();
            }
        });
        chessBoard.addMouseMotionListener(new MouseMotionAdapter()
        {
            // 当鼠标移动时,改变选中点的坐标
            public void mouseMoved(MouseEvent e)
            {
                selectedX = (e.getX() - X_OFFSET) / RATE;
                selectedY = (e.getY() - Y_OFFSET) / RATE;
                chessBoard.repaint();
            }
        });
        f.add(chessBoard);
        f.pack();
        f.setVisible(true);
    }
    public static void main(String[] args)throws Exception
    {
        Gobang gb = new Gobang();
        gb.init();
    }
    class ChessBoard extends JPanel
    {
        // 重写JPanel的paint方法,实现绘画
        public void paint(Graphics g)
        {
            // 将绘制五子棋棋盘
            g.drawImage(table , 0 , 0 , null);
            // 绘制选中点的红框
            if (selectedX >= 0 && selectedY >= 0)
                g.drawImage(selected , selectedX * RATE + X_OFFSET ,
                        selectedY * RATE + Y_OFFSET, null);
            // 遍历数组,绘制棋子。
            for (int i = 0 ; i < BOARD_SIZE ; i++)
            {
                for ( int j = 0 ; j < BOARD_SIZE ; j++)
                {
                    // 绘制黑棋
                    if (board[i][j].equals("●"))
                    {
                        g.drawImage(black , i * RATE + X_OFFSET
                                , j * RATE + Y_OFFSET, null);
                    }
                    // 绘制白棋
                    if (board[i][j].equals("○"))
                    {
                        g.drawImage(white, i * RATE  + X_OFFSET
                                , j * RATE  + Y_OFFSET, null);
                    }
                }
            }
        }
    }
}

422101-20161204231601677-2019914113.png

手绘

package ch11;


import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;

public class HandDraw
{
    // 画图区的宽度
    private final int AREA_WIDTH = 500;
    // 画图区的高度
    private final int AREA_HEIGHT = 400;
    // 下面的preX、preY保存了上一次鼠标拖动事件的鼠标坐标
    private int preX = -1;
    private int preY = -1;
    // 定义一个右键菜单用于设置画笔颜色
    PopupMenu pop = new PopupMenu();
    MenuItem redItem = new MenuItem("红色");
    MenuItem greenItem = new MenuItem("绿色");
    MenuItem blueItem = new MenuItem("蓝色");
    // 定义一个BufferedImage对象
    BufferedImage image = new BufferedImage(AREA_WIDTH
            , AREA_HEIGHT , BufferedImage.TYPE_INT_RGB);
    // 获取image对象的Graphics
    Graphics g = image.getGraphics();
    private Frame f = new Frame("简单手绘程序");
    private DrawCanvas drawArea = new DrawCanvas();
    // 用于保存画笔颜色
    private Color foreColor = new Color(255, 0 ,0);
    public void init()
    {
        // 定义右键菜单的事件监听器。
        ActionListener menuListener = e ->
        {
            if (e.getActionCommand().equals("绿色"))
            {
                foreColor = new Color(0 , 255 , 0);
            }
            if (e.getActionCommand().equals("红色"))
            {
                foreColor = new Color(255 , 0 , 0);
            }
            if (e.getActionCommand().equals("蓝色"))
            {
                foreColor = new Color(0 , 0 , 255);
            }
        };
        // 为三个菜单添加事件监听器
        redItem.addActionListener(menuListener);
        greenItem.addActionListener(menuListener);
        blueItem.addActionListener(menuListener);
        // 将菜单项组合成右键菜单
        pop.add(redItem);
        pop.add(greenItem);
        pop.add(blueItem);
        // 将右键菜单添加到drawArea对象中
        drawArea.add(pop);
        // 将image对象的背景色填充成白色
        g.fillRect(0 , 0 ,AREA_WIDTH , AREA_HEIGHT);
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH , AREA_HEIGHT));
        // 监听鼠标移动动作
        drawArea.addMouseMotionListener(new MouseMotionAdapter()
        {
            // 实现按下鼠标键并拖动的事件处理器
            public void mouseDragged(MouseEvent e)
            {
                // 如果preX和preY大于0
                if (preX > 0 && preY > 0)
                {
                    // 设置当前颜色
                    g.setColor(foreColor);
                    // 绘制从上一次鼠标拖动事件点到本次鼠标拖动事件点的线段
                    g.drawLine(preX , preY , e.getX() , e.getY());
                }
                // 将当前鼠标事件点的X、Y坐标保存起来
                preX = e.getX();
                preY = e.getY();
                // 重绘drawArea对象
                drawArea.repaint();
            }
        });
        // 监听鼠标事件
        drawArea.addMouseListener(new MouseAdapter()
        {
            // 实现鼠标松开的事件处理器
            public void mouseReleased(MouseEvent e)
            {
                // 弹出右键菜单
                if (e.isPopupTrigger())
                {
                    pop.show(drawArea , e.getX() , e.getY());
                }
                // 松开鼠标键时,把上一次鼠标拖动事件的X、Y坐标设为-1。
                preX = -1;
                preY = -1;
            }
        });
        f.add(drawArea);
        f.pack();
        f.setVisible(true);
    }
    public static void main(String[] args)
    {
        new HandDraw().init();
    }
    class DrawCanvas extends Canvas
  

  {
        // 重写Canvas的paint方法,实现绘画
        public void paint(Graphics g)
        {
            // 将image绘制到该组件上
            g.drawImage(image , 0 , 0 , null);
        }
    }
}

422101-20161204232215927-2040015373.png

弹球游戏

package ch11;

/**
 * Created by Jiqing on 2016/12/4.
 */

import java.util.Random;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class PinBall
{
    // 桌面的宽度
    private final int TABLE_WIDTH = 300;
    // 桌面的高度
    private final int TABLE_HEIGHT = 400;
    // 球拍的垂直位置
    private final int RACKET_Y = 340;
    // 下面定义球拍的高度和宽度
    private final int RACKET_HEIGHT = 20;
    private final int RACKET_WIDTH = 60;
    // 小球的大小
    private final int BALL_SIZE = 16;
    private Frame f = new Frame("弹球游戏");
    Random rand = new Random();
    // 小球纵向的运行速度
    private int ySpeed = 10;
    // 返回一个-0.5~0.5的比率,用于控制小球的运行方向。
    private double xyRate = rand.nextDouble() - 0.5;
    // 小球横向的运行速度
    private int xSpeed = (int)(ySpeed * xyRate * 2);
    // ballX和ballY代表小球的坐标
    private int ballX = rand.nextInt(200) + 20;
    private int ballY = rand.nextInt(10) + 20;
    // racketX代表球拍的水平位置
    private int racketX = rand.nextInt(200);
    private MyCanvas tableArea = new MyCanvas();
    Timer timer;
    // 游戏是否结束的旗标
    private boolean isLose = false;
    public void init()
    {
        // 设置桌面区域的最佳大小
        tableArea.setPreferredSize(
                new Dimension(TABLE_WIDTH , TABLE_HEIGHT));
        f.add(tableArea);
        // 定义键盘监听器
        KeyAdapter keyProcessor = new KeyAdapter()
        {
            public void keyPressed(KeyEvent ke)
            {
                // 按下向左、向右键时,球拍水平坐标分别减少、增加
                if (ke.getKeyCode() == KeyEvent.VK_LEFT)
                {
                    if (racketX > 0)
                        racketX -= 10;
                }
                if (ke.getKeyCode() == KeyEvent.VK_RIGHT)
                {
                    if (racketX < TABLE_WIDTH - RACKET_WIDTH)
                        racketX += 10;
                }
            }
        };
        // 为窗口和tableArea对象分别添加键盘监听器
        f.addKeyListener(keyProcessor);
        tableArea.addKeyListener(keyProcessor);
        // 定义每0.1秒执行一次的事件监听器。
        ActionListener taskPerformer = evt ->
        {
            // 如果小球碰到左边边框
            if (ballX  <= 0 || ballX >= TABLE_WIDTH - BALL_SIZE)
            {
                xSpeed = -xSpeed;
            }
            // 如果小球高度超出了球拍位置,且横向不在球拍范围之内,游戏结束。
            if (ballY >= RACKET_Y - BALL_SIZE &&
                    (ballX < racketX || ballX > racketX + RACKET_WIDTH))
            {
                timer.stop();
                // 设置游戏是否结束的旗标为true。
                isLose = true;
                tableArea.repaint();
            }
            // 如果小球位于球拍之内,且到达球拍位置,小球反弹
            else if (ballY  <= 0 ||
                    (ballY >= RACKET_Y - BALL_SIZE
                            && ballX > racketX && ballX <= racketX + RACKET_WIDTH))
            {
                ySpeed = -ySpeed;
            }
            // 小球坐标增加
            ballY += ySpeed;
            ballX += xSpeed;
            tableArea.repaint();
        };
        timer = new Timer(100, taskPerformer);
        timer.start();
        f.pack();
        f.setVisible(true);
    }
    public static void main(String[] args)
    {
        new PinBall().init();
    }
    class MyCanvas extends Canvas
    {
        // 重写Canvas的paint方法,实现绘画
        public void paint(Graphics g)
        {
            // 如果游戏已经结束
            if (isLose)
            {
                g.setColor(new Color(255, 0, 0));
                g.setFont(new Font("Times" , Font.BOLD, 30));
                g.drawString("游戏已结束!" , 50 ,200);
            }
            // 如果游戏还未结束
            else
            {
                // 设置颜色,并绘制小球
                g.setColor(new Color(240, 240, 80));
                g.fillOval(ballX , ballY , BALL_SIZE, BALL_SIZE);
                // 设置颜色,并绘制球拍
                g.setColor(new Color(80, 80, 200));
                g.fillRect(racketX , RACKET_Y
                        , RACKET_WIDTH , RACKET_HEIGHT);
            }
        }
    }
}

422101-20161204232426349-1220009273.png

剪贴板

package ch11;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.datatransfer.*;

/**
 * Created by Jiqing on 2016/12/4.
 */
public class SimpleClipboard {
    // 剪贴板
    private Frame f = new Frame("简单的剪贴板程序");
    private Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    // 定义用于复制的文本框
    private TextArea jtaCopyTo = new TextArea(5,20);
    private TextArea jtaPaste  = new TextArea(5,20);
    private Button btCopy = new Button("复制");
    private Button btPaste = new Button("粘贴");
    public void init() {
        Panel p = new Panel();
        p.add(btCopy);
        p.add(btPaste);
        btCopy.addActionListener(event ->{
            StringSelection contents = new StringSelection(jtaCopyTo.getText());
            clipboard.setContents(contents,null);
        });

        btPaste.addActionListener(event ->{
            if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
                try {
                    String content = (String)clipboard.getData(DataFlavor.stringFlavor);
                    jtaPaste.append(content);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        Box box = new Box(BoxLayout.X_AXIS);
        box.add(jtaCopyTo);
        box.add(jtaPaste);
        f.add(p,BorderLayout.SOUTH);
        f.add(box,BorderLayout.CENTER);
        f.pack();
        f.setVisible(true);
    }

    public static void main(String[] args) {
        new SimpleClipboard().init();
    }

}

422101-20161204232434568-365950012.png

监听

package ch11;
import java.awt.*;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

/**


 * Created by Jiqing on 2016/12/3.
 */
public class WindowListenerTest {
    private Frame f = new Frame("测试");
    private TextArea ta = new TextArea(6,40);
    public void init() {
        // 为窗口添加窗口事件监听器
        f.addWindowListener(new MyListener());
        f.add(ta);
        f.pack();
        f.setVisible(true);
    }

    // 实现一个窗口监听器类
    class MyListener implements WindowListener {
        public void windowActivated(WindowEvent e) {
            ta.append("窗口被激活!\n");
        }

        public void windowClosed(WindowEvent e) {
            ta.append("窗口被成功关闭!\n");
        }

        public void windowClosing(WindowEvent e) {
            ta.append("用户关闭窗口!\n");
            System.exit(0);
        }

        public void windowDeactivated(WindowEvent e) {
            ta.append("窗口失去焦点!\n");
        }

        public void windowDeiconified(WindowEvent e) {
            ta.append("窗口被恢复!\n");
        }

        public void windowIconified(WindowEvent e) {
            ta.append("窗口被最小化!\n");
        }

        public void windowOpened(WindowEvent e) {
            ta.append("窗口初次被打开!\n");
        }
    }

    public static void main(String[] args) {
        new WindowListenerTest().init();
    }
}

适配器

package ch11;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

/**
 * Created by Jiqing on 2016/12/4.
 */
public class WindowAdapterTest {
    private Frame f = new Frame("测试");
    private TextArea ta = new TextArea(6,40);
    public void init() {
        f.addWindowListener(new MyListener());
        f.add(ta);
        f.pack();
        f.setVisible(true);
    }
    class MyListener extends WindowAdapter{
        public void windowClosing(WindowEvent e) {
            System.out.println("用户关闭窗口!\n");
            System.exit(0);
        }

    }
    public static void main(String[] args) {
        new WindowAdapterTest().init();
    }
}


本文转自TBHacker博客园博客,原文链接:http://www.cnblogs.com/jiqing9006/p/6132370.html,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
十分钟掌握java多线程进阶
十分钟掌握java多线程进阶
0 0
Java多线程进阶——JUC常见类和死锁
java中的JUC就是java.util.concurrent包下的一些标准类或者接口,这个包里的东西都是和多线程相关的,以下就是这个包中常见的类和接口的用法及示例:
0 0
Java多线程进阶——CAS与synchronized优化
Java多线程进阶——CAS与synchronized优化
0 0
Java多线程进阶——常见的锁策略
Java多线程进阶——常见的锁策略
0 0
【Java编程进阶】面向对象思想初识
之前我们学习了 C 语言,在使用 C 语言解决实际的问题时,我们会把解决问题的步骤封装成不同的函数,然后在需要使用时调用函数执行,这就是面向过程编程的思想。使用面向过程使程序的流程十分清楚,例如完成早上去上学这件事情,我们要粗略做以下的步骤,只要以函数的形式详细的完成每个步骤,就成功的解决了这个问题: - 起床 - 穿衣服 - 刷牙洗脸 - 上学 而面向对象中,我们可以抽象出一个学生类,该类中包含了上面的四个方法,此时我们并不需要按上面的步骤来完成。
0 0
【Java编程进阶】花费数小时,带你学透Java数组,这些常用方法你还记得吗?
数组在 Java 编程中是一个非常基础且重要的概念,简单来说,就是把具有相同数据类型的数据存储在地址连续的内存空间中,目的是在程序设计中方便这一类数据的管理。每一个内容都有编号,这个编号从 0 开始,称为数组下标。数组分为一维数组和二维数组,还有一些和数组相关的重要内容,例如数组中元素的查找,排序等,下面做详细的讲解。
0 0
【Java编程进阶】方法初识
方法是组合在一起来执行操作语句的集合`,将具有独立功能的代码块组织成为一个整体,使其具有特殊功能,并且能实现达到代码复用的效果。例如我们要在程序中多次判断一个数字是奇数还是偶数,这时,我们就可以将判断一个数的奇偶性的代码段封装成一个方法,后面再使用时只需要调用这个方法,大大提高了编程的效率和代码的复用性。
0 0
【Java编程进阶】流程控制结构详解
程序流程控制结构是指以某种顺序执行的一系列动作,用于解决某个问题。程序可以通过控制语句来对程序实现选择、循环、转向和返回等流程控制。程序控制结构包括:顺序结构、分支结构、循环结构。
0 0
【Java编程进阶】Java数据类型详解
程序运行时产生的临时数据我们存储在被称为变量的内存单元里,而变量的创建,就是在内存中分配一块内存空间。为什么要定义不同的数据类型呢?当我们预先定义好数据类型后,内存管理系统在给变量分配内存空间时,就可以根据变量的数据类型为变量分配合适的存储空间,分配的空间只能用来储存该类型数据。总的来说,给变量定义数据类型可以让内存空间得到充分的利用。
0 0
【Java编程进阶】运算符与表达式
计算机诞生的初衷是为了进行数学的运算,Java 作为一门计算机编程语言,同样也提供了用于操纵变量的`运算符`来进行数学运算。
0 0
文章
问答
文章排行榜
最热
最新
相关电子书
更多
JAVA 应用排查全景图
立即下载
Java工程师必读手册
立即下载
Java应用提速(速度与激情)
立即下载