图形用户界面GUI（二）

事件处理

在 AWT 编程中 ，所有用户的操作，都必须都需要经过一套事件处理机制来完成，而 Frame 和组件本身并没有事件处理能力。

GUI事件处理机制

在某个组件上发生某些操作的时候，会自动的触发一段代码的执行。

事件源(Event Source)：操作发生的场所，通常指某个组件，例如按钮、窗口等；
事件（Event）：在事件源上发生的操作可以叫做事件，GUI会把事件都封装到一个Event对象中，如果需要知道该事件的详细信息，就可以通过Event对象来获取。
事件监听器(Event Listener):当在某个事件源上发生了某个事件，事件监听器就可以对这个事件进行处理。
注册监听：把某个事件监听器(A)通过某个事件(B)绑定到某个事件源©上，当在事件源C上发生了事件B之后，那么事件监听器A的代码就会自动执行。

public class EventDemo1 {
    
    
     Frame frame=new Frame("这是文件处理");
    TextField tf=new TextField(30);
    //创建事件源对象
    JButton button=new JButton("确定");

    public  void init(){
    
    
        //创建监听器对象
        MyListener myListener=new MyListener();
        //注册监听
        button.addActionListener(myListener);
        
        frame.add(tf,BorderLayout.NORTH);
        frame.add(button);
        frame.pack();
        frame.setVisible(true);
    }
//自定义内部类，实现接口，重写方法
    private class MyListener implements ActionListener{
    
    
        @Override
        public void actionPerformed(ActionEvent e) {
    
    
            tf.setText("hello world");
        }
    }
}

常见事件和事件监听器

事件监听器必须实现事件监听器接口， AWT 提供了大量的事件监听器接口用于实现不同类型的事件监听器，用于监听不同类型的事件 。 AWT 中提供了丰富的事件类，用于封装不同组件上所发生的特定操作， AWT 的事件类都是 AWTEvent 类的子类 ， AWTEvent是 EventObject 的子类。

低级事件

这类事件是基于某个特定动作的事件。比如进入、点击、拖放等动作的鼠标事件，再比如得到焦点和失去焦点等焦点事件。

高级事件

这类事件并不会基于某个特定动作，而是根据功能含义定义的事件。

事件监听器分类

不同的事件需要使用不同的监听器监听，不同的监听器需要实现不同的监听器接口， 当指定事件发生后 ， 事件监听器就会调用所包含的事件处理器(实例方法)来处理事件 。

public class ListenerDemo1 {
    
    
    public static void main(String[] args) {
    
    
    Frame frame = new Frame("这里测试监听器");
    //创建一个单行文本域
    TextField tf = new TextField(30);
    //给文本域添加TextListener，监听内容的变化
    tf.addTextListener(new TextListener() {
    
    
       @Override
       public void textValueChanged(TextEvent e) {
    
    
          System.out.println("当前内容："+tf.getText());;
        }
     });

    //给frame注册ContainerListener监听器，监听容器中组件的添加
     frame.addContainerListener(new ContainerAdapter() {
    
    
        @Override
        public void componentAdded(ContainerEvent e) {
    
    
             Component child = e.getChild();
             System.out.println("容器中添加了新组件："+child);
            }
        });

        //添加tf到frame
        frame.add(tf);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

//用户点击错号即可关闭
public class ListenerDemo2 {
    
    
    public static void main(String[] args) {
    
    
        Frame frame = new Frame("这里测试WindowListener");

        frame.addWindowListener(new WindowAdapter() {
    
    
        //文件适配器WindowAdapter,根据自己选择选取内部方法
            @Override
            public void windowClosing(WindowEvent e) {
    
    
                System.exit(0);
            }
        });

        frame.setBounds(200,200,500,300);
        frame.setVisible(true);
    }
}

菜单组件

在实际开发中，除了主界面，还有一类比较重要的内容就是菜单相关组件，可以通过菜单相关组件很方便的使用特定的功能，在AWT中，菜单相关组件的使用和之前学习的组件是一模一样的，只需要把菜单条、菜单、菜单项组合到一起，按照一定的布局，放入到容器中即可。
（1）常见的菜单组件：

菜单组件名称	功能
MenuBar	菜单条 ， 菜单的容器 。
Menu	菜单组件 ， 菜单项的容器 。 它也是Menultem的子类 ，所以可作为菜单项使用
PopupMenu	上下文菜单组件(右键菜单组件)
Menultem	菜单项组件 。
CheckboxMenuItem	复选框菜单项组件

（2）菜单相关组件的使用：

1.准备菜单项组件，这些组件可以是MenuItem及其子类对象。
2.准备菜单组件Menu或者PopupMenu(右击弹出子菜单)，把第一步中准备好的菜单项组件添加进来。
3.准备菜单条组件MenuBar，把第二步中准备好的菜单组件Menu添加进来。
4.把第三步中准备好的菜单条组件添加到窗口对象中显示。

（3）相关技巧：

1.如果要在某个菜单的菜单项之间添加分割线，那么只需要调用Menu的add（new MenuItem(-)）即可。

2.如果要给某个菜单项关联快捷键功能，那么只需要在创建菜单项对象时设置即可，例如给菜单项关联 ctrl+shif+/ 快捷键，只需要：new MenuItem("菜单项名字",newMenuShortcut(KeyEvent.VK_Q,true);

public class SimpleMenu {
    
    
    //创建窗口
    private Frame frame = new Frame("这里测试菜单相关组件");
    
    //创建菜单条组件
    private MenuBar menuBar = new MenuBar();
    
    //创建文件菜单组件
    private Menu fileMenu = new Menu("文件");
    //创建编辑菜单组件
    private Menu editMenu = new Menu("编辑");
    //创建格式菜单
    private Menu formatMenu = new Menu("格式");
    
    //创建新建菜单项
    private MenuItem newItem = new MenuItem("新建");
    //创建保存菜单项
    private MenuItem saveItem = new MenuItem("保存");
    //创建退出菜单项
    private MenuItem exitItem = new MenuItem("退出");

    //创建自动换行选择框菜单项
    private CheckboxMenuItem autoWrap = new CheckboxMenuItem("自动换行");
    //创建复制菜单项
    private MenuItem copyItem = new MenuItem("复制");
    //创建粘贴菜单项
    private MenuItem pasteItem = new MenuItem("粘贴");
    //创建注释菜单项
    private MenuItem commentItem = new MenuItem("注释");
    //创建取消注释菜单项
    private MenuItem cancelItem = new MenuItem("取消注释");

    //创建一个文本域
    private TextArea ta = new TextArea(6, 40);


    public void init(){
    
    
        //定义菜单事件监听器
        ActionListener listener = new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                String command = e.getActionCommand();
                ta.append("单击“"+command+"”菜单\n");
                if (command.equals("退出")){
    
    
                    System.exit(0);
                }
            }
        };

        //为注释菜单项和退出菜单项注册监听器
        commentItem.addActionListener(listener);
        exitItem.addActionListener(listener);

        //为文件菜单fileMenu添加菜单项
        fileMenu.add(newItem);
        fileMenu.add(saveItem);
        fileMenu.add(exitItem);

        //为编辑菜单editMenu添加菜单项
        editMenu.add(autoWrap);
        editMenu.add(copyItem);
        editMenu.add(pasteItem);

        //为格式化菜单formatMenu添加菜单项
        formatMenu.add(commentItem);
        formatMenu.add(cancelItem);

        //将格式化菜单添加到编辑菜单中，作为二级菜单
        editMenu.add(new MenuItem("-"));
        editMenu.add(formatMenu);


        //将文件菜单和编辑菜单添加到菜单条中
        menuBar.add(fileMenu);
        menuBar.add(editMenu);


        //把菜单条设置到frame窗口上
        frame.setMenuBar(menuBar);

        //把文本域添加到frame中
        frame.add(ta);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }


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

public class PopupMenuTest {
    
    

    private Frame frame = new Frame("这里测试PopupMenu");

    //创建PopubMenu菜单
    private PopupMenu popupMenu = new PopupMenu();

    //创建菜单条

    private MenuItem commentItem = new MenuItem("注释");
    private MenuItem cancelItem = new MenuItem("取消注释");
    private MenuItem copyItem = new MenuItem("复制");
    private MenuItem pasteItem = new MenuItem("保存");


    //创建一个文本域
    private TextArea ta = new TextArea("我爱中华！！！", 6, 40);

    //创建一个Panel
    private  Panel panel = new Panel();

    public void init(){
    
    

        //把菜单项添加到PopupMenu中
        popupMenu.add(commentItem);
        popupMenu.add(cancelItem);
        popupMenu.add(copyItem);
        popupMenu.add(pasteItem);

        //设置panel大小
        panel.setPreferredSize(new Dimension(300,100));

        //把PopupMenu添加到panel中
        panel.add(popupMenu);

        //为panel注册鼠标事件
        panel.addMouseListener(new MouseAdapter() {
    
    
            @Override
            public void mouseReleased(MouseEvent e) {
    
    
                boolean flag = e.isPopupTrigger();
                //判断当前鼠标操作是不是触发PopupMenu的操作
                if (flag){
    
    
                    //让PopupMenu显示在panel上，并且跟随鼠标事件发生的地方显示
                    popupMenu.show(panel,e.getX(),e.getY());
                }
            }
        });

        //把ta添加到frame中间区域中
        frame.add(ta);

        //把panel添加到frame底部
        frame.add(panel,BorderLayout.SOUTH);

        //设置frame最佳大小，并可视；
        frame.pack();
        frame.setVisible(true);

    }

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

}

组件绘图原理

在AWT中，真正提供绘图功能的是Graphics对象，那么Component组件和Graphics对象存在什么关系，才能让Component绘制自身图形呢？在Component类中，提供了下列三个方法来完成组件图形的绘制与刷新：

paint(Graphics g):绘制组件的外观；
update(Graphics g):内部调用paint方法，刷新组件外观；
repaint():调用update方法，刷新组件外观；

一般情况下，update和paint方法是由AWT系统负责调用，如果程序要希望系统重新绘制组件，可以调用repaint方法完成。
​

Graphics类

AWT中提供了Canvas类充当画布，提供了Graphics类来充当画笔，通过调用Graphics对象的setColor()方法可以给画笔设置颜色。

画图的步骤：
1.自定义类，继承Canvas类，重写paint(Graphics g)方法完成画图；
2.在paint方法内部，真正开始画图之前调用Graphics对象的setColor()、setFont()等方法设置画笔的颜色、字体等属性；
3.调用Graphics画笔的drawXxx()方法开始画图。

画图的核心:使用Graphics画笔在Canvas画布上画出什么颜色、什么样式的图形.

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

    public class SimpleDraw {
    
    
       //标记画的是椭圆还是矩形
        private final String RECT_SHAPE="rect";
        private final String OVAL_SHAPE="oval";

        private Frame frame = new Frame("这里测试绘图");

        private Button drawRectBtn = new Button("绘制矩形");
        private Button drawOvalBtn = new Button("绘制椭圆");

        //定义变量用来保存当前用户需要绘制什么样的图形
        private String shape="";
        //创建画布
        private MyCanvas drawArea = new MyCanvas();
        
        public void init(){
    
    

            //为按钮添加点击事件
            drawRectBtn.addActionListener(new ActionListener() {
    
    
                @Override
                public void actionPerformed(ActionEvent e) {
    
    
                    shape = RECT_SHAPE;
                    drawArea.repaint();
                }
            });

            drawOvalBtn.addActionListener(new ActionListener() {
    
    
                @Override
                public void actionPerformed(ActionEvent e) {
    
    
                    shape = OVAL_SHAPE;
                    drawArea.repaint();
                }
            });

            //定义一个Panel，装载两个按钮
            Panel p = new Panel();
            p.add(drawRectBtn);
            p.add(drawOvalBtn);

            //把panel添加到frame底部
            frame.add(p,BorderLayout.SOUTH);

            //设置画布的大小
            drawArea.setPreferredSize(new Dimension(300,200));
            //把画布添加到frame中

            frame.add(drawArea);

            frame.pack();
            frame.setVisible(true);


        }

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


        //1.自定义类，继承Canvas类，重写paint方法

        private class MyCanvas extends Canvas{
    
    
            @Override
            public void paint(Graphics g) {
    
    
                Random r = new Random();

                if (shape.equals(RECT_SHAPE)){
    
    
                    //绘制矩形
                    g.setColor(Color.BLACK);
                    g.drawRect(r.nextInt(200),r.nextInt(100),40,60);
                }

                if(shape.equals(OVAL_SHAPE)){
    
    
                    //绘制椭圆
                    g.setColor(Color.RED);
                    g.drawOval(r.nextInt(200),r.nextInt(100),60,40);
                }

            }
        }
    }

Java也可用于开发一些动画。所谓动画，就是间隔一定的时间(通常小于0 . 1秒 )重新绘制新的图像，两次绘制的图像之间差异较小，肉眼看起来就成了所谓的动画 。

​为了实现间隔一定的时间就重新调用组件的 repaint()方法，可以借助于 Swing 提供的Timer类，Timer类是一个定时器， 它有如下一个构造器 ：
Timer(int delay, ActionListener listener): 每间隔 delay 毫秒，系统自动触发 ActionListener 监听器里的事件处理器方法，在方法内部我们就可以调用组件的repaint方法，完成组件重绘。

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

public class PinBall {
    
    
    //桌面宽度
    private final int TABLE_WIDTH = 300;
    //桌面高度
    private final int TABLE_HEIGHT = 400;
    //球拍的高度和宽度
    private final int RACKET_WIDTH = 60;
    private final int RACKET_HEIGHT = 20;
    //小球的大小
    private final int BALL_SIZE = 16;
    //定义小球纵向运行速度
    private int ySpeed = 10;
    //小球横向运行速度
    private int xSpeed = 5;
    //定义小球的初始坐标
    private int ballX = 120;
    private int ballY = 20;
    //定义球拍的初始坐标，x坐标会发生变化，y坐标不会发生变化
    private int rackeX = 120;
    private final int RACKET_Y = 340;

    //声明定时器
    private Timer timer;
    //定义游戏结束的标记
    private boolean isLose = false;

    //声明一个桌面
    private MyCanvas tableArea = new MyCanvas();

    //创建窗口对象
    private Frame frame = new Frame("弹球游戏");

    public void init(){
    
    
        //设置桌面区域的最佳大小
        tableArea.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));
        //把桌面添加到frame中
        frame.add(tableArea);

        //定义键盘监听器
        KeyListener keyListener = new KeyAdapter(){
    
    

            //监听键盘 ←  → 按下操作，当指定的键按下时，球拍的水平坐标分别会增加或者减少
            @Override
            public void keyPressed(KeyEvent e) {
    
    
                int keyCode = e.getKeyCode();
                if (keyCode==KeyEvent.VK_LEFT){
    
    //←
                    //没有到左边界，可以继续向左移动
                    if (rackeX>0){
    
    
                        rackeX-=10;
                    }
                }

                if (keyCode==KeyEvent.VK_RIGHT){
    
    //→
                    //没有到右边界，可以继续向右移动
                    if (rackeX<TABLE_WIDTH-RACKET_WIDTH){
    
    
                        rackeX+=10;
                    }
                }
            }
        };

        //为窗口和tableArea分别添加键盘事件
        frame.addKeyListener(keyListener);
        tableArea.addKeyListener(keyListener);

        //定义ActionListener，用来监听小球的变化情况
        ActionListener timerTask = new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                //小球碰到左右边框
                if (ballX<=0 || ballX>=TABLE_WIDTH-BALL_SIZE){
    
    
                    xSpeed=-xSpeed;
                }
                //小球的高度超出了球拍的位置，且横向不在球拍范围内，则游戏结束
                if (ballY > RACKET_Y && (ballX<rackeX || ballX>rackeX+RACKET_WIDTH)){
    
    
                    //结束定时器
                    timer.stop();
                    //把游戏结束的标记设置为true
                    isLose = true;
                    //重绘界面
                    tableArea.repaint();

                }
                //如果小球横向在球拍范围内，且到达球拍位置或者到达顶端位置，则小球反弹
                if (ballY<=0 || (ballY>=RACKET_Y-BALL_SIZE && ballX>=rackeX && ballX<=rackeX+RACKET_WIDTH)){
    
    
                    ySpeed=-ySpeed;
                }

                //更新小球的坐标
                ballX+=xSpeed;
                ballY+=ySpeed;

                //重绘桌面
                tableArea.repaint();
            }
        };

        //设置定时器，定时任务就是timerTask
        timer = new Timer(100,timerTask);
        timer.start();

        //设置frame最佳大小，并可视

        frame.pack();
        frame.setVisible(true);


    }

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

    private class MyCanvas extends Canvas{
    
    

        //重写paint方法，实现绘图
        @Override
        public void paint(Graphics g) {
    
    
            //判断游戏是否结束
            if (isLose){
    
    //结束
                g.setColor(Color.BLUE);
                g.setFont(new Font("Times",Font.BOLD,30));
                g.drawString("游戏结束！",50,200);
            }else{
    
    //没有结束

                //设置颜色并绘制小球
                g.setColor(Color.RED);
                g.fillOval(ballX,ballY,BALL_SIZE,BALL_SIZE);

                //设置颜色并绘制球拍
                g.setColor(Color.PINK);
                g.fillRect(rackeX,RACKET_Y,RACKET_WIDTH,RACKET_HEIGHT);
            }

        }
    }
}

处理位图

AWT 允许在组件上绘制位图， Graphics 提供了 drawlmage() 方法用于绘制位图，该方法需要一个Image参数一一代表位图，通过该方法就可以绘制出指定的位图 。

方法：
1.创建Image的子类对象BufferedImage(int width,int height,int ImageType),创建时需要指定位图的宽高及类型属性；此时相当于在内存中生成了一张图片；

2.调用BufferedImage对象的getGraphics()方法获取画笔，此时就可以往内存中的这张图片上绘图了，绘图的方法和之前学习的一模一样；

3.调用组件的drawImage()方法，一次性的内存中的图片BufferedImage绘制到特定的组件上。

使用位图绘制组件的好处：

使用位图来绘制组件，相当于实现了图的缓冲区，此时绘图时没有直接把图形绘制到组件上，而是先绘制到内存中的BufferedImage上，等全部绘制完毕，再一次性的图像显示到组件上即可，这样用户的体验会好一些。

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

public class HandDraw {
    
    
    //定义画图区的宽高
    private final int AREA_WIDTH = 500;
    private final int AREA_HEIGHT = 400;

    //定义变量，保存上一次鼠标拖动时，鼠标的坐标
    private int preX = -1;
    private int preY = -1;

    //定义一个右键菜单，用于设置画笔的颜色
    private PopupMenu colorMenu = new PopupMenu();
    private MenuItem redItem = new MenuItem("红色");
    private MenuItem greenItem = new MenuItem("绿色");
    private MenuItem blueItem = new MenuItem("蓝色");

    //定义一个BufferedImage对象
    private BufferedImage image = new BufferedImage(AREA_WIDTH,AREA_HEIGHT,BufferedImage.TYPE_INT_RGB);
    //获取BufferedImage对象关联的画笔
    private Graphics g = image.getGraphics();

    //定义窗口对象
    private Frame frame = new Frame("简单手绘程序");

    //定义画布对象
    private Canvas drawArea =  new Canvas(){
    
    
        @Override
        public void paint(Graphics g) {
    
    
            //把位图image绘制到0,0坐标点
            g.drawImage(image,0,0,null);
        }
    };

    //定义一个Color对象，用来保存用户设置的画笔颜色,默认为黑色
    private Color forceColor = Color.BLACK;

    public void init(){
    
    
        //定义颜色菜单项单击监听器
        ActionListener menuListener = new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                String command = e.getActionCommand();
                switch (command){
    
    
                    case "红色":
                        forceColor=Color.RED;
                        break;
                    case "绿色":
                        forceColor = Color.GREEN;
                        break;
                    case "蓝色":
                        forceColor = Color.BLUE;
                        break;
                }
            }
        };

        //为三个菜单项添加点击事件
        redItem.addActionListener(menuListener);
        greenItem.addActionListener(menuListener);
        blueItem.addActionListener(menuListener);

        //把菜单项添加到右键菜单中
        colorMenu.add(redItem);
        colorMenu.add(greenItem);
        colorMenu.add(blueItem);

        //把右键菜单添加到绘图区域drawArea
        drawArea.add(colorMenu);

        //将iamge图片背景设置为白色
        g.fillRect(0,0,AREA_WIDTH,AREA_HEIGHT);

        //设置绘图区域drawArea的大小
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH,AREA_HEIGHT));

        //绘图区域drawArea设置鼠标移动监听器
        drawArea.addMouseMotionListener(new MouseMotionAdapter() {
    
    
            //用于绘制图像
            @Override
            public void mouseDragged(MouseEvent e) {
    
    //按下鼠标键并拖动会触发
                //如果上次鼠标的坐标在绘图区域，才开始绘图
                if (preX>0 && preY>0){
    
    
                    //设置当前选中的画笔颜色
                    g.setColor(forceColor);
                    //绘制线条，需要有两组坐标，一组是上一次鼠标拖动鼠标时的坐标，一组是现在鼠标的坐标
                    g.drawLine(preX,preY,e.getX(),e.getY());
                }

                //更新preX和preY
                preX = e.getX();
                preY = e.getY();

                //重新绘制drawArea组件
                drawArea.repaint();

            }
        });

        drawArea.addMouseListener(new MouseAdapter() {
    
    

            //用于弹出右键菜单
            @Override
            public void mouseReleased(MouseEvent e) {
    
    //松开鼠标键会触发
                boolean popupTrigger = e.isPopupTrigger();
                if (popupTrigger){
    
    
                    //把colorMenu显示到drawArea画图区域，并跟随鼠标显示
                    colorMenu.show(drawArea,e.getX(),e.getY());
                }

                //当鼠标松开时，把preX和preY重置为-1
                preX = -1;
                preY = -1;

            }
        });

        //把drawArea添加到frame中
        frame.add(drawArea);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
    
    
        new HandDraw().init();
    }
}

ImageIO的使用

软件都支持打开本地磁盘已经存在的图片，然后进行编辑，编辑完毕后，再重新保存到本地磁盘。我们可以用imageIO类来操作本地磁盘的图片文件。

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

public class ReadAndSaveImage {
    
    

    private Frame frame = new Frame("图片查看器");

    private BufferedImage image;

    private class MyCanvas  extends Canvas{
    
    

        @Override
        public void paint(Graphics g) {
    
    
            if (image!=null){
    
    
                g.drawImage(image,0,0,image.getWidth(),image.getHeight(),null);
            }
        }
    }

    private MyCanvas imageComponent = new MyCanvas();

    public void init() throws Exception{
    
    

        //设置菜单项
        MenuBar mb = new MenuBar();
        Menu menu = new Menu("文件");
        MenuItem openItem = new MenuItem("打开");
        MenuItem saveItem = new MenuItem("另存为");

        openItem.addActionListener(e -> {
    
    
            //弹出对话框，选择本地图片
            FileDialog oDialog = new FileDialog(frame);
            oDialog.setVisible(true);
            //读取用户选择的图片
            String dir = oDialog.getDirectory();
            String file = oDialog.getFile();
            try {
    
    
                image = ImageIO.read(new File(dir,file));

                imageComponent.repaint();

            } catch (IOException e1) {
    
    
                e1.printStackTrace();
            }

        });


        saveItem.addActionListener(e -> {
    
    
            //弹出对话框，另存为
            FileDialog sDialog = new FileDialog(frame,"保存图片",FileDialog.SAVE);
            sDialog.setVisible(true);
            String dir = sDialog.getDirectory();
            String file = sDialog.getFile();

            try {
    
    
                ImageIO.write(image,"JPEG",new File(dir,file));
            } catch (IOException e1) {
    
    
                e1.printStackTrace();
            }
        });

        mb.add(menu);
        menu.add(openItem);
        menu.add(saveItem);

        frame.setMenuBar(mb);
        frame.add(imageComponent);

        frame.setBounds(200,200,800,600);

        frame.setVisible(true);

        frame.addWindowListener(new WindowAdapter() {
    
    
            @Override
            public void windowClosing(WindowEvent e) {
    
    
                System.exit(0);
            }
        });
    }



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

五子棋

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.File;

public class Gobang {
    
    

    //定义三个BufferedImage，分别代表棋盘图、黑子图、白子图
    private BufferedImage table;
    private BufferedImage black;
    private BufferedImage white;
    //定义一个BufferedImage，代表当鼠标移动时将要下子的选择框
    private BufferedImage selected;

    //定义棋盘的宽高，这里的定义尺寸和给定的board.jpg图片的尺寸一致因为棋盘背景是通过图片加载的
    private final int TABLE_WIDTH = 535;
    private final int TABLE_HEIGHT = 536;

    //定义棋盘中，每行和每列可下子的数目，这个数目跟给定的board.jpg中的数目是一致的，都为15
    private final int  BOARD_SIZE = 15;

    //定义每个棋子所占棋盘总宽度的大小比率；每个棋子所占宽度 535/15=35
    private final int RATE = TABLE_WIDTH/BOARD_SIZE;

    //定义棋盘有效区域与背景图坐标之间的偏移值，x坐标右移5个像素，y坐标下移6个像素
    private final int X_OFFSET = 5;
    private final int Y_OFFSET = 6;


    /*

        定义一个二维数组充当棋盘上每个位置处的棋子；
        该数组的索引与该棋子在棋盘上的坐标需要有一个对应关系：
            例如： 索引[2][3]处的棋子，对一个的真实绘制坐标应该是：

                xpos = 2*RATE+X_OFFSET=75;
                ypos = 3*RATE+Y_OFFSET=111;

     */
    private int[][] board = new int[BOARD_SIZE][BOARD_SIZE];//如果存储0，代表没有棋子，如果存储1，代表黑棋，如果存储2，代表白棋

    //定义五子棋游戏窗口
    private JFrame f = new JFrame("五子棋游戏");

    //定义五子棋游戏棋盘对应的Canvas组件
    private class ChessBoard extends JPanel{
    
    
        //重写paint方法，实现绘画
        @Override
        public void paint(Graphics g) {
    
    
            //绘制五子棋棋盘
            g.drawImage(table,0,0,null);
            //绘制选中点的红框
            if (selectX>0 && selectY>0){
    
    
                g.drawImage(selected,selectX*RATE+X_OFFSET,selectY*RATE+Y_OFFSET,null);
            }

            //遍历数组，绘制棋子
            for (int i = 0; i < BOARD_SIZE; i++) {
    
    
                for (int j = 0; j < BOARD_SIZE; j++) {
    
    
                    //绘制黑棋

                    if (board[i][j]==1){
    
    
                        g.drawImage(black,i*RATE+X_OFFSET,j*RATE+Y_OFFSET,null);
                    }

                    //绘制白棋
                    if (board[i][j]==2){
    
    
                        g.drawImage(white,i*RATE+X_OFFSET,j*RATE+Y_OFFSET,null);
                    }
                }
            }
        }
    }

    private ChessBoard chessBoard = new ChessBoard();

    //定义变量，记录当前选中的坐标点对应的boad数组中对应的棋子索引；
    private int selectX = -1;
    private int selectY = -1;

    //定义一个变量，记录当前用户选择下的是白棋还是黑棋还是清除，清除：0，黑棋：1，白棋：2；
    private int chessCategory = 1;

    //定义Panel,放置点击按钮
    Panel p = new Panel();
    private Button whiteBtn = new Button("白棋");
    private Button blackBtn = new Button("黑棋");
    private Button clearBtn = new Button("删除");

    public void updateBtnColor(Color whiteBtnColor,Color blackBtnColor,Color clearBtnColor){
    
    
        whiteBtn.setBackground(whiteBtnColor);
        blackBtn.setBackground(blackBtnColor);
        clearBtn.setBackground(clearBtnColor);
    }

    public void init() throws Exception{
    
    

        //初始化按钮的颜色
        updateBtnColor(Color.LIGHT_GRAY,Color.GREEN,Color.LIGHT_GRAY);
        whiteBtn.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                chessCategory = 2;
                updateBtnColor(Color.GREEN,Color.LIGHT_GRAY,Color.LIGHT_GRAY);
            }
        });
        blackBtn.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                chessCategory=1;
                updateBtnColor(Color.LIGHT_GRAY,Color.GREEN,Color.LIGHT_GRAY);
            }
        });
        clearBtn.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                chessCategory=0;
                updateBtnColor(Color.LIGHT_GRAY,Color.LIGHT_GRAY,Color.GREEN);
            }
        });

        p.add(whiteBtn);
        p.add(blackBtn);
        p.add(clearBtn);
        //把Panel放入到frame底部
        f.add(p,BorderLayout.SOUTH);


        //初始化黑棋，白棋，棋盘,选中框
        table = ImageIO.read(new File("awt_demo\\board.jpg"));
        black = ImageIO.read(new File("awt_demo\\black.gif"));
        white = ImageIO.read(new File("awt_demo\\white.gif"));
        selected = ImageIO.read(new File("awt_demo\\selected.gif"));
        //初始化board数组，默认情况下，所有位置处都没有棋子
        for (int i = 0; i < BOARD_SIZE; i++) {
    
    
            for (int j = 0; j < BOARD_SIZE; j++) {
    
    
                board[i][j]=0;
            }
        }

        //设置chessBoard的最佳大小
        chessBoard.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));

        //给chessBoard注册鼠标监听器
        chessBoard.addMouseListener(new MouseAdapter() {
    
    
            //鼠标单击会触发
            @Override
            public void mouseClicked(MouseEvent e) {
    
    
                //将用户鼠标的坐标，转换成棋子的坐标
                int xPos = (e.getX()-X_OFFSET)/RATE;
                int yPos = (e.getY()-Y_OFFSET)/RATE;

                board[xPos][yPos] = chessCategory;

                //重绘chessBoard
                chessBoard.repaint();
            }

            //当鼠标退出棋盘区域后，复位选中坐标,重绘chessBoard，要保证红色选中框显示正确
            @Override
            public void mouseExited(MouseEvent e) {
    
    
                selectX=-1;
                selectY=-1;
                chessBoard.repaint();
            }
        });

        //给chessBoard注册鼠标移动监听器
        chessBoard.addMouseMotionListener(new MouseMotionAdapter() {
    
    
            //当鼠标移动时，修正selectX和selectY，重绘chessBoard，要保证红色选中框显示正确
            @Override
            public void mouseMoved(MouseEvent e) {
    
    
                //将鼠标的坐标，转换成棋子的索引
                selectX = (e.getX()-X_OFFSET)/RATE;
                selectY = (e.getY()-Y_OFFSET)/RATE;
                chessBoard.repaint();
            }
        });

        //把chessBoard添加到Frame中
        f.add(chessBoard);



        //设置frame最佳大小并可见
        f.pack();
        f.setVisible(true);

    }

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

}