javaSE——AWT编程（二）

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量303 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41819893/article/details/121069460
版权

四、AWT常用组件

1、基本组件

  • Button：按钮

  • Canvas：画布

  • Checkbox：复选框组件

  • CheckboxGroup：用于将多个Checkbox组件合成一组

  • Choice：下拉式选择框组件

  • Frame：窗口

  • Label：标签类

  • List：列表框组件

  • Panel：不能单独存在基本容器类，必须放到其他容器中

  • Scrollbar：滑动条组件

  • ScrollPane：带水平及垂直滚动条的容器组件

  • TextArea：多行文本域

  • TextField：单行文本域

import javax.swing.*;
import java.awt.*;
public class Demo {
     Frame frame = new Frame("test");
    TextArea ta = new TextArea(5,20);
    Choice colorChooser = new Choice();
    CheckboxGroup cbg = new CheckboxGroup();
    Checkbox male = new Checkbox("男",cbg,true);
    Checkbox female = new Checkbox("女",cbg,false);
    Checkbox isMarried = new Checkbox("是否已婚？");
    TextField tf = new TextField(50);
    Button ok = new Button("确定");
    List colorlist = new List(6,true);
    public void init(){
        //组装界面        
//组装底部        
Box bBox = Box.createHorizontalBox();
        bBox.add(tf);
        bBox.add(ok);
        frame.add(bBox,BorderLayout.SOUTH);
        //组装选择部分
        colorChooser.add("红色");
        colorChooser.add("蓝色");
        colorChooser.add("绿色");
        Box cBox = Box.createHorizontalBox();
        cBox.add(colorChooser);
        cBox.add(male);
        cBox.add(female);
        cBox.add(isMarried);
        //组装文本域以及选择部分
        Box topleft = Box.createVerticalBox();
        topleft.add(ta);
        topleft.add(cBox);
        //组装左边和列表框
        colorlist.add("红色");
        colorlist.add("绿色");
        colorlist.add("蓝色");
        Box top = Box.createHorizontalBox();
        top.add(topleft);
        top.add(colorlist);
        frame.add(top);
        //设置frame为最佳大小
        frame.pack();
        frame.setVisible(true);
    }    
public static void main(String[] args) {
        new Demo().init();    
}
}

2、对话框（Dialog）

Dialog是windows的子类，是一个容器类，属于特殊组件，对话框是可以独立存在的顶级窗口。

对话框有如下两点需要注意：

（1）对话框通常依赖于其他窗口，就是通常有一个parent窗口

（2）对话框有非模式（non-modal）和模式（modal）两种，当某个模式对话框被打开之后，该模式对话框总是位于它依赖的窗口之上；在模式对话框被关闭之前，它依赖的窗口无法获得焦点

对话框有多个重载构造器，它的构造器可能有如下3个参数：

（1）owner：指定该对话框所依赖的窗口，既可以是窗口，也可以是对话框。

（2）title：指定该对话框的窗口标题

（3）modal：指定该对话框是否是模式的，true或者false

非模式对话框和模式对话框的用法：

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class DialogTest {
    public static void main(String[] args) {
        Frame frame = new Frame("test");
        //创建两个对话框Dialog对象，一个模式的，一个非模式的
        Dialog d1 = new Dialog(frame, "模式对话框",true);
        Dialog d2 = new Dialog(frame, "非模式对话框",true);
        //通过setBounds方法设置Dialog的位置及大小
        d1.setBounds(20,20,300,200);
        d2.setBounds(20,20,300,200);
        //创建两个按钮
        Button b1 = new Button("打开模式对话框");
        Button b2 = new Button("打开非模式对话框");
        //需要给这两个按钮添加点击后的行为
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d1.setVisible(true);
            }
        });
            b2.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    d2.setVisible(true);
                }
            });
        //把按钮添加到frame中
        frame.add(b1,BorderLayout.NORTH);
        frame.add(b2);
        // 设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

Dialog类还有一个子类：FileDialog，代表一个文件对话框，用来打开或者保存文件，FileDialog提供三个构造参数：parent、title、mode，其中mode指定该窗口用于打开或保存文件。

    FileDialog提供如下两个方法来获取被打开/保存文件的路径：

  1. getDirectory()：获取FileDialog被打开/保存文件的绝对路径

  2. getFile()：获取FileDialog被打开/保存文件的文件名

如何使用FileDialog来创建打开/保存文件的对话框：

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FileDialogTest {
    public static void main(String[] args) {
        Frame frame = new Frame("test");
        //创建两个FileDialog对象
        FileDialog f1 = new FileDialog(frame,"选择要打开的文件", FileDialog.LOAD);
        FileDialog f2 = new FileDialog(frame,"选择要打开的文件", FileDialog.SAVE);
        //创建两个按钮
        Button b1 = new Button("打开文件");
        Button b2 = new Button("保存文件");
        //给这两个按钮设置点击后的行为，获取打开或者保存的路径文件名
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                f1.setVisible(true);
                //获取选择的路径和文件
                String directory = f1.getDirectory();
                String file = f1.getFile();
                System.out.println("打开文件的路径为："+directory);
                System.out.println("打开的文件名称为："+file);
            }
        });
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                f2.setVisible(true);
                //获取选择的路径和文件
                String directory = f2.getDirectory();
                String file = f2.getFile();
                System.out.println("保存文件的路径为："+directory);
                System.out.println("保存的文件名称为："+file);
            }
        });
        //把按钮添加到frame中
        frame.add(b1,BorderLayout.NORTH);
        frame.add(b2);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

五、事件处理

1、java事件模型的流程

事件处理机制四个重要概念：

  • Source：事件源，即触发事件的对象

  • EventObject：事件对象，即带有 EventSource 信息的事件对象，是对EventSource的包装

  • Eventlistener：事件监听器，对该事件的处理

  • 注册监听：把某个事件监听器（A）通过某个事件（B）绑定到某个事件源（C）上，当在事件源c上发生了事件B后，那么事件监听器A的代码就会自动执行

事件处理机制：

  1. 实现事件监听器类

  2. 创建普通组件（事件源），创建事件监听对象

  3. 调用addAxxxListener()方法将事件监听器对象注册给普通事件（事件源）。当事件源上发生指定事件时，AWT会触发事件监听器，由事件监听器调用下相应的方法（事件处理器）来处理事件，事件源上所发生的事情会作为参数传入事件处理器。

2、事件和事件监听器

事件分为两大类：

（1）低级事件：指的是基于特定动作的事件，比如进入、点击、拖放等动作的鼠标事件，当组件得到焦点、失去焦点时出发焦点事件

  • ComponentEvent：组件事件：组件尺寸的变化、移动

  • ContainerEvent：容器事件：组件增加、移动

  • WindowEvent：窗口事件：关闭窗口、窗口闭合、图标化

  • FocusEvent：焦点事件：焦点的获得和丢失

  • KeyEvent：键盘事件：键按下、释放

  • MouseEvent：鼠标事件：鼠标单击、移动

（2）、高级事件：基于语义的事件，可以不和特定的动作相关联，而依赖于触发此事件的类。

  • ActionEvent 动作事件：按钮按下，TextField中按下Enter键

  • AdjustmentEvent 调节事件：在滚动条上移动滑块以调节数值

  • ItemEvent 项目事件：选择项目，不选择”项目改变”

  • TextEvent 文本事件：文本对象改变

通常是一个类，该类必须实现与该事件类型相对应的接口。对应的接口被称为事件监听器接口。事件监听器接口类的名称与事件类的名称相对应。例如，MouseEvent事件类的监听器接口名为MouseListener。

所有事件监听器方法返回的返回类型都是void

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Event {
    Frame frame = new Frame("test");
    //创建文本框和按钮
    TextField tf = new TextField(30);
    Button ok = new Button("确定");
    public void init() {
        //组装视图
        //监听器
        //MyListener myListener = new MyListener();
        //注册监听
        ok.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("ok按钮被点击了");
                tf.setText("HelloWorld");
            }
        });
        //把tf和b1放入frame中
        frame.add(tf, BorderLayout.NORTH);
        frame.add(ok);
        //设置最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
    /**
    private class MyListener implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            tf.setText("HelloWorld");
        }
    }
     */
    public static void main(String[] args) {
        new Event().init();
    }
}

实例：

通过ContainerListener监听Frame容器添加组件

通过TextListener监听TextFiled内容变化

通过ItemListener监听Choice条目选中状态变化

给Frame设置WindowsListener，监听用户关闭的动作

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Demo {
    public static void main(String[] args) {
        Frame frame = new Frame("test");
        //创建组件
        TextField tf = new TextField(50);
        Choice names = new Choice();
        names.add("张三");
        names.add("李四");
        names.add("王五");
        //给文本域添加TextListener，监听内容的变化
        tf.addTextListener(new TextListener() {
            @Override
            public void textValueChanged(TextEvent e) {
                String text = tf.getText();
                System.out.println("当前文本框的内容为："+text);
            }
        });
        //给下拉选择框添加ItemListener，监听条目选项的变化
        names.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {
                Object item = e.getItem();
                System.out.println("下拉选择框的条目为："+item);
            }
        });
        //给frame注册ContainerListener监听器，监听容器中组件的添加
        frame.addContainerListener(new ContainerListener() {
            @Override
            public void componentAdded(ContainerEvent e) {
                Component child = e.getChild();
                System.out.println("frame中添加了："+child);
            }
            @Override
            public void componentRemoved(ContainerEvent e) {
            }
        });
        //设置windowsListener，监听用户关闭的动作
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                //停止当前程序
                System.exit(0);
            }
        });
        //添加到frame中
        Box hBox = Box.createHorizontalBox();
        hBox.add(names);
        hBox.add(tf);
        frame.add(hBox);
        frame.pack();
        frame.setVisible(true);
    }
}

3、事件适配器

事件适配器时监听接口的空实现——事件适配器实现了监听器接口，并未该接口里的每个方法都提供了实现，这种实现是一种空实现（方法体内没有任何代码的实现）

六、AWT菜单

1、菜单条、菜单和菜单项

  1. MenuBar：菜单条，菜单的容器

  2. Menu：菜单组件，菜单项的容器

  3. PopupMenu：上下文菜单组件（右键菜单组件）

  4. MenuItem：菜单项组件

  5. CheckboxMenuItem：复选框菜单项组件

  6. MenuShortcut

菜单相关组件使用步骤：

  1. 准备菜单项组件，这些组件可以是MenuItem及其子类对象

  2. 准备菜单组件Menu或者PopupMenu（右击弹出子菜单），把第一步中准备好的菜单项组件添加进来

  3. 准备菜单条组件MenuBar，把第二部中准备好的菜单组件Menu添加进来

  4. 把第三部中准备好的菜单条组件添加到窗口对象中来

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
public class AWTTest{
        private Frame frame = new Frame("test");
        //创建并添加菜单栏
        MenuBar menuBar = new MenuBar();
        //创建菜单组件
        Menu menuFile = new Menu("文件");
        Menu menuEdit = new Menu("编辑");
        Menu menuformat = new Menu("格式");
        //菜单项组件
        MenuItem auto = new MenuItem("自动换行");
        MenuItem copy = new MenuItem("复制");
        MenuItem paste = new MenuItem("粘贴");
        MenuItem comment = new MenuItem("注释 Ctrl+shift+Q",new MenuShortcut(KeyEvent.VK_Y,true));
        MenuItem cancelComment = new MenuItem("取消注释");
        TextArea ta = new TextArea(6,40);
        public void init(){
            comment.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    ta.append("您点击了菜单项："+e.getActionCommand());
                }
            });
            menuformat.add(comment);
            menuformat.add(cancelComment);
            //编辑菜单
            menuEdit.add(auto);
            menuEdit.add(copy);
            menuEdit.add(paste);
            menuEdit.add(menuformat);
            //组装菜单条
            menuBar.add(menuFile);
            menuBar.add(menuEdit);
            //把菜单条放入到frame中
            frame.setMenuBar(menuBar);
            frame.add(ta);

            frame.pack();
            frame.setVisible(true);
        }
    public static void main(String[] args) {
        new AWTTest().init();
    }
}

2、右键菜单

    创建右键菜单的步骤如下：

  1. 创建PopupMenu的实例

  2. 创建多个MenuItem的多个实例，依次将这些实例加入PopupMenu中

  3. 将PopupMenu加入到目标组件中

  4. 为需要出现上下文菜单的组件编写鼠标监听器

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

public class draw {
    private final String RECT_shape = "rect";
    private final String OVAL_SHAPE = "oval";
    private Frame frame = new Frame("测试");
    Button buttonRect = new Button("绘制矩形");
    Button buttonOval = new Button("绘制椭圆");
    //定义一个变量，记录当前要绘制椭圆还是矩形
    private String shape = "";
    //自定义类，继承Canvas类，重写paint(Graphics g)方法完成画图
    private class MyCanyas extends Canvas {
        public void paint(Graphics g) {
            //绘制不同的图形
            if (shape.equals(RECT_shape)) {
                //绘制矩形
                g.setColor(Color.black);    //设置当前画笔的颜色为黑色
                g.drawRect(100, 100, 150, 100);
            }else if (shape.equals(OVAL_SHAPE)) {
                //绘制椭圆
                g.setColor(Color.RED);
                g.drawOval(100, 100, 150, 100);
            }
        }
    }
    //创建自定义画布对象
    MyCanyas drawArea = new MyCanyas();
    //组装视图
    public void init(){
        buttonRect.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //修改标记的值为rect
                shape = RECT_shape;
                drawArea.repaint();
            }
        });
        buttonOval.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //修改标记的值为Oval
                shape = OVAL_SHAPE;
                drawArea.repaint();
            }
        });
        //创建Panel，承载按钮
        Panel p = new Panel();
        p.add(buttonRect);
        p.add(buttonOval);
        //将Panel放入Frame中
        frame.add(p, BorderLayout.SOUTH);
        //设置drawArea的大小
        drawArea.setPreferredSize(new Dimension(300,300));
        frame.add(drawArea);
        //设置窗口可见以及大小
        frame.pack();
        frame.setVisible(true);
}
    public static void main(String[] args) {
        new draw().init();
    }
}

七、在AWT中绘图

1、绘图的实现原理

    在Component类里提供了和绘图有关的三个方法

  1. paint(Graphics g)：绘制组件的外观

  2. update(Graphics g)：调用paint()方法，刷新组件外观

  3. repaint()：调用update()方法，刷新组件外观

2、画图的步骤

1、自定义类，继承Canvas类，重写paint(Graphics g)方法完成画图

2、在paint方法内部，真正开始画图之前调用Graphics对象的setColor()，setFont()等方法设置画笔的颜色，字体等属性

3、调用Graphics画笔的drawXXX()方法开始画图

Graphics提供如下几个方法绘制几何图形：

  1. drawLine()：画直线

  2. setColor()：设置画笔颜色（需传入Color参数）

  3. setFont()：设置画笔字体（需传入Font参数）

  4. drawString()：绘制字符串

  5. drawRect()：绘制矩形

  6. drawRoundRect()：绘制圆角矩形

  7. drawOval()：绘制椭圆形状

  8. drawPolygon()：绘制多边形边框

  9. drawArc()：绘制一段圆弧

  10. drawPolyline()：绘制折线

  11. fillRect()：填充一个矩形区域

  12. fillRoundRect()：填充一个圆角矩形区域

  13. fillOval()：填充椭圆区域

  14. fillPolygon()：填充一个多边形区域

  15. fillArc()：填充圆弧和圆弧两个端点到中心点连线所包围的区域

  16. draImage()：绘制位图

package AWT;

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

public class Image {
    private Frame frame = new Frame();
    //定义画图区的宽高
    private final int AREA_WIDTH = 500;
    private final int AREA_HEIGHT = 400;
    //定义一个右键菜单，用于设置画笔的颜色
    private PopupMenu colorMenu = new PopupMenu();
    private MenuItem redItem = new MenuItem("红色");
    private MenuItem greenItem = new MenuItem("绿色");
    private MenuItem blueItem = new MenuItem("蓝色");
    //定义一个变量，记录当前画笔的颜色
    private Color forceColor = Color.BLACK;
    //创建一个BufferImage位图对象
    BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT, BufferedImage.TYPE_INT_RGB);
    //通过位图获取关联的Giaphics对象
    Graphics g = image.getGraphics();
    //自定义一个类，继承Canvas
    private class MyCanvas extends Canvas {
        public void paint(Graphics g) {
            g.drawImage(image, 0, 0, null);
        }
    }
    MyCanvas drawArea = new MyCanvas();
    //定义变量，记录鼠标拖动过程中，上一次所处的坐标
    private int preX = -1;
    private int preY = -1;
    public void init() {
    //组装视图
    ActionListener listener = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            String actionCommand = e.getActionCommand();
            switch (actionCommand) {
                case "红色":
                    forceColor = Color.RED;
                    break;
                case "绿色":
                    forceColor = Color.GREEN;
                    break;
                case "蓝色":
                    forceColor = Color.BLUE;
                    break;
            }
        }
    };
        redItem.addActionListener(listener);
        greenItem.addActionListener(listener);
        blueItem.addActionListener(listener);
        colorMenu.add(redItem);
        colorMenu.add(greenItem);
        colorMenu.add(blueItem);
        //把colorMenushe设置给绘图区域
        drawArea.add(colorMenu);
        drawArea.addMouseListener(new MouseAdapter() {
            @Override
        drawArea.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {   //当鼠标键抬起时被调用
                boolean popupTrigger = e.isPopupTrigger();
                if(popupTrigger){
                    colorMenu.show(drawArea,e.getX(),e.getY());
                }
                //重置preX和preY
                preX = -1;
                preY = -1;
            }
        });
        //设置位图背景为白色
        g.setColor(Color.WHITE);
        g.fillRect(0,0,AREA_WIDTH,AREA_HEIGHT);
        //通过监听鼠标的移动，完成线条的绘制
        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.repaint();
            }
        });
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH,AREA_HEIGHT));
        frame.add(drawArea);
        //设置可见
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        new Image().init();
    }
}

3、处理位图

位图使用步骤：

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

  2. 调用BufferedImage对象的getGraphics()方法获取画笔，此时就可以往内存中的这张图片上绘图了，绘图的方法与上无差

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

Image抽象类和BufferedImage实现类

    Image类代表位图，但它是一个抽象类，无法直接创建Image对象，为此Java提供了BufferedImage子类，这个子类是一个可访问图像数据缓冲区的Image实现类，该类提供了一个简单的构造器，用于创建一个BufferedImage对象

  • BufferedImage(int width,int height,int imageType)：创建指定大小、指定图像类型的BufferedImage对象

package AWT;

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

public class Image {
    private Frame frame = new Frame();
    //定义画图区的宽高
    private final int AREA_WIDTH = 500;
    private final int AREA_HEIGHT = 400;
    //定义一个右键菜单，用于设置画笔的颜色
    private PopupMenu colorMenu = new PopupMenu();
    private MenuItem redItem = new MenuItem("红色");
    private MenuItem greenItem = new MenuItem("绿色");
    private MenuItem blueItem = new MenuItem("蓝色");
    //定义一个变量，记录当前画笔的颜色
    private Color forceColor = Color.BLACK;
    //创建一个BufferImage位图对象
    BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT, BufferedImage.TYPE_INT_RGB);
    //通过位图获取关联的Giaphics对象
    Graphics g = image.getGraphics();
    //自定义一个类，继承Canvas
    private class MyCanvas extends Canvas {
        public void paint(Graphics g) {
            g.drawImage(image, 0, 0, null);
        }
    }
    MyCanvas drawArea = new MyCanvas();
    //定义变量，记录鼠标拖动过程中，上一次所处的坐标
    private int preX = -1;
    private int preY = -1;
    public void init() {
    //组装视图
    ActionListener listener = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            String actionCommand = e.getActionCommand();
            switch (actionCommand) {
                case "红色":
                    forceColor = Color.RED;
                    break;
                case "绿色":
                    forceColor = Color.GREEN;
                    break;
                case "蓝色":
                    forceColor = Color.BLUE;
                    break;
            }
        }
    };
        redItem.addActionListener(listener);
        greenItem.addActionListener(listener);
        blueItem.addActionListener(listener);
        colorMenu.add(redItem);
        colorMenu.add(greenItem);
        colorMenu.add(blueItem);
        //把colorMenushe设置给绘图区域
        drawArea.add(colorMenu);
        drawArea.addMouseListener(new MouseAdapter() {
            @Override
        drawArea.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {   //当鼠标键抬起时被调用
                boolean popupTrigger = e.isPopupTrigger();
                if(popupTrigger){
                    colorMenu.show(drawArea,e.getX(),e.getY());
                }
                //重置preX和preY
                preX = -1;
                preY = -1;
            }
        });
        //设置位图背景为白色
        g.setColor(Color.WHITE);
        g.fillRect(0,0,AREA_WIDTH,AREA_HEIGHT);
        //通过监听鼠标的移动，完成线条的绘制
        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.repaint();
            }
        });
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH,AREA_HEIGHT));
        frame.add(drawArea);
        //设置可见
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        new Image().init();
    }
}

4、使用ImageIO输出/输出位图

    ImageIO可以读取磁盘上的位图文件，但并不支持读写全部格式的文件

  1. static String[] getReaderFileSuffies()：返回一个String数组，该数组列出ImageIO所有能读的图形文件的文件后缀

  2. static String[] gatReaderFormatNames()：返回一个String数组，该数组列出ImageIO所有能读的图形文件的非正式格式名称

  3. static String[] getWriterFileSuffies()：返回一个String数组，该数组列出ImageIO所有能写的图形文件的文件后缀

  4. static String[] aetWriterFormatNames()：返回一个String数组，该数组列出ImageIO所有能读的图形文件的非正式格式后缀

package AWT;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class ImageIO {
    private Frame frame = new Frame("图片查看器");
    MenuBar menuBar = new MenuBar();
    Menu menu = new Menu("文件");
    Menu open = new Menu("打开");
    Menu save = new Menu("另存为");
    //声明BufferedImage对象，记录本地存取到内存中的图片
    BufferedImage image;
    private class Mycanvas extends Canvas{
        public void paint(Graphics g){
            g.drawImage(image,0,0,null);

        }
    }
    Mycanvas drawArea = new Mycanvas();
    public void init() throws Exception {
        //组装视图
        open.addActionListener(e -> {
           FileDialog fileDialog = new FileDialog(frame,"打开图片",FileDialog.LOAD);
           fileDialog.setVisible(true);
           //获取用户选择的图片路径以及名称
            String dir = fileDialog.getDirectory();
            String fileName = fileDialog.getFile();
            try{
                javax.imageio.ImageIO.read(new File(dir,fileName));
                drawArea.repaint();
            }catch(IOException ex){
                ex.printStackTrace();
            }
        });
        save.addActionListener(e -> {
            //展示文件对话框
            FileDialog fileDialog = new FileDialog(frame,"保存图片",FileDialog.LOAD);
            fileDialog.setVisible(true);
            //获取用户设置的保存路径文件名称
            String dir = fileDialog.getDirectory();
            String fileName = fileDialog.getFile();
            try{
                javax.imageio.ImageIO.write(image,"JPEG",new File(dir,fileName));
            }catch (IOException ex){
                ex.printStackTrace();
            }
        });
        menu.add(open);
        menu.add(save);
        menuBar.add(menu);
        //把菜单条放到窗口中
        frame.setMenuBar(menuBar);
        frame.add(drawArea);
        //设置大小并可见
        frame.pack();
        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 ImageIO().init();
    }
}

5、剪贴板

（1）、传递文本

    AWT提供了一个StringSelection用于传输文本字符串，将一段文本内容（字符串对象）放进剪贴板中的步骤如下：

    1、创建一个Clipboard实例，即可以创建系统剪贴板，也可以创建本地剪贴板。创建系统剪贴板如下代码：

Clipboard Clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

        创建本地剪贴板如下代码：

Clipboard Clipboard = new Clipboard("cb");

    2、将需要放入剪贴板中的字符串封装成StringSelection对象

StringSelectin st = new StringSelection(targetStr);

    3、调用剪贴板对象的setContents()方法将StringSelection放入剪贴板中，该方法需要两个参数，第一个是Transferable对象，代表放进剪贴板中的对象；第二个参数是ClipboardOwner对象，代表剪贴板数据的所有者，通常无需关心剪贴板数据的所有者，所以把第二个参数设为null。

（2）、使用系统剪贴板传递图像

如果要将图像放入剪贴板内，需要提供一个Transferable接口的实现类，该类只需要封装一个image对象，并且向外表现为imageFlavor内容

（3）、使用本地剪贴板传递对象引用

本地剪贴板可以保存任何类型的 Java 对象，包括自定义类型的对象。为了将任意类型的 Java 对象保存到剪贴板中，DataFlavor 里提供了一个 javaJVMLocalObjectMimeType 的常量，该常量是一个 MIME类型字符串：application/x-java-jvm-local-objectref，将 Java 对象放入本地剪贴板中必须使用该 MIME 类型。该 MIME 类型表示仅将对象引用复制到剪贴板中，对象引用只有在同一个虚拟机中才有效，所以只能使用本地剪贴板。创建本地剪贴板的代码如下：

clipboard clipboard = new Clipboard("cp");

    以使用JFrame对象调用show()方法使窗体可见；也可以使用setVisible(true)方法使窗体可见。同样也可以使用setSize(int x,int y)方法设置窗体大小，其中x与y变量分别代表窗体的宽与高。创建窗体后，需要给予窗体一个窗体关闭方式，可以调用setDefaultCloseOperation()方法关闭窗体

import java.awt.*; //导入awt包
import javax.swing.*; //导入swing包     
public class class1 extends JFrame{ //定义一个类继承JFrame类
    public void CreateJFrame(String title){//定义一个CreateJFrame方法
        JFrame jf =new JFrame(title);//实例化一个JFrame对象
        Container container = jf .getContentPane();//获取一个容器;
        JLabel jl =new JLabel();//创建一个JLabel标签
        jl.setHorizontalAlignment(SwingConstants.CENTER);//使标签上的文字居中
        container.add(jl);//将标签添加到容器中
        container.setBackground(Color.green);//设置容器的背景颜色
        jf.setVisible(true);//使窗口可视
        jf.setSize(800,800);//设置窗口大小
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//设置窗口关闭方式
    }         
    public static void main(String[] args) {
        //在主方法中调用CreatJFrame()方法
        new class1().CreateJFrame("创建一个JFrame窗体");        
    }
}

DF10F-0001A
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java事件监听器
02-02
当你将一个类用作事件监听器时，你已经设置好一个特定的事件类型，它会用该类进行监听。接下来的操作是：一个匹配的监听器必须被加入到该组件中 组件被创建之后，可以在组件上调用如下方法来将监听器与它联系起来 addActionListener( ) 可用于 Button,Check, TexyField 等组件 addAdjustmentListener( ) 可用于 ScrollBar 组件 addFocusListener( ) 可用于所有可视化组件 addItemListener( ) 可用于 Button,CheckBox 等组件 addKeyListener( ) 可用于所有可视化组件 addMouseListener( ) 可用于所有可视化组件 addMouseMotionListener( ) 可用于所有可视化组件 addWindowsListener( ) 可用于 Window,Frame等组件 例：下面语句创建一个 Button 对象，并将它与动作事件监听器联系起来 Button button = new Button( “OK” ) ; button . addActionListener ( this ) ; //this 指明当前类就是事件监听器 2 使用方法 （1）动作事件（ActionEvent） 发生在用户完成了使用下列组件之一的动作： Button , CheckBox , ComboBox , TextField , RadioButton 类为了能够处理这些事件必须实现接口 ActionListener 。 每个产生一个动作事件的组件上要调用方法 addActionListener( ) 方法 actionPerformed(ActionEvent evt) 是接口 ActionListener 惟一的 方法采用如下格式： public void actionPerformed(ActionEvent evt) { //…… } 在 ActionEvent 对象上可以使用的方法： getSource( ) 获取产生事件组件的组件名 getActionCommand( ) 获取与组件有关的文本，如命令按钮的标签 键盘事件（KeyEvent） 发生在键盘上的某个键被按下时。 类为了能够处理这些事件必须实现接口 KeyListener 。 每个产生一个键盘事件的组件上要调用方法 addKeyListener( ) 在接口 KeyListener 中有三个方法： public void keyPressed(KeyEvent evt) { //…… } public void keyReleased(KeyEvent evt) { //…… } public void keyTyped(KeyEvent evt) { //…… } 在 KeyEvent 对象上可以使用的方法： getKeyChar( ) 返回与事件相关的键盘字符的 Unicode 码 . . . . . . . . . .
java代码练习 work172
虾米大王的学习历程
09-22 157
work172.java package test09; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuIte
Java动作监听器的实现
hy041112的博客
08-24 742
在Java界面开发的相关内容中，当我们点击界面内部的按钮时，需要实现一定的功能，而不是作为摆设，这就需要用到动作监听器。而相应的也需要一段代码来使其运行。在界面开发中实现按钮功能的作者提供了一个自动调用的方法，这个方法没有内容，需要自己添加，使得系统底层调用这个方法是会有代码执行。动作监听器的代码：java.awt.event.ActionListener //需要调用1.首先需要一个类LoginListener来实现接口ActionListener动作2.重写方法。
GUI编程--02--AWT.事件监听
时光里的博客
05-30 259
事件监听 事件监听：当某个事情发生的时候，干什么。 addActionListener() 设置监听 案例1 :点击一个button ,显示台打印相关信息 import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; public clas
AWT_事件监听（Java）
...
06-13 204
网络编程_事件监听（Java） package Demo01; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; public class TestActionEvent { public static void mai
JAVASE事件监听
Narnat的博客
09-10 243
【代码】JAVASE事件监听。
类 java.awt.event.ActionEvent 等的使用
热门推荐
wq1967724的博客
05-25 1万+
使用 ActionEvent 的软件包 java.awt 包含用于创建用户界面和绘制图形图像的所有类。  java.awt.dnd Drag 和 Drop 是一种直接操作操作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。  java.awt.event 提供处理由 AWT 组件所激发的各类
【Java】图形用户接口(GUI)
richest_qi的博客
11-22 806
第一个GUI import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class Test implements ActionListener{ JButton button; public static void main(String args[]){ Test t = new
java监听器ActionListener 的入门小应用
ixbao的博客
10-04 747
java监听器ActionListener 的入门小应用
Java -- GUI编程之AWT编程
weixin_45362099的博客
01-30 235
组件： 窗口 弹窗 面板 文本框 列表框 按钮 图片 监听事件 鼠标事件 键盘事件 破解工具 1、Frame – 界面 package com.wgh.lesson01; import java.awt.*; public class TestFrame { public static void main(String[] args) { Frame frame = new Frame("我的第一个Java图像界面窗口."); // 设置可见性
Java AWT简介
zq2379的博客
11-06 3246
Java AWT简介
JavaSE多线程编程专题.pptx
06-08
JavaSE多线程编程专题
JavaSE教程——布小禅.docx
09-18
JavaSE教程——布小禅.docx，专门为零基础人设计的教程
基于UDP协议的Socket通信.rar_UDP_javase_网络编程
09-15
socket编程，基于udp面向对象，实现服务端和用户端之间连接互动
JavaSE实战——客户端上传文件到服务端
05-05
JavaSE实战，java网络编程，文件，TCP等知识，适合java练手小项目
JAVASE-基础 - 网络编程
07-30
介绍了网络编程的概念，网络编程的代码实现
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1101
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 994
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Spring Cloud——LoadBalancer
最新发布
????
05-01 830
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
javase网络编程网络模型
08-16
- *1* [JavaSE——网络编程](https://blog.csdn.net/yzl1293346757/article/details/126192384)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DF10F-0001A

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值