javaSE——AWT编程（二）

最新推荐文章于 2022-10-09 23:17:25 发布
最新推荐文章于 2022-10-09 23:17:25 发布
阅读量420 收藏 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
关注
专栏目录
Java学习笔记--GUI之Swing类
weixin_45129136的博客
05-15 722
窗口 import javax.swing.*; import java.awt.*; public class JFrameDemo { //init():初始化 public void init(){ //顶级窗口 JFrame jframe = new JFrame("这是一个JFrame窗口"); jframe.setVisible(true); jframe.setBounds(100,100,100,100);
给Java中TextField控件的回车事件。
秦亚伟的专栏-金蝶 EAS BOS、苍穹平台技术
05-07 5680
今天在 BOS开发中，给单据叙事簿上（hangshi的配餐单）的条件文本框增加回车自动刷新的事件，发现如下监听器都不起作用：  kDTextField1.addActionListener(new ActionListener(){   public void actionPerformed(ActionEvent arg0) {    System.out.println("回车了！"); 
java-使用import java.awt.*
fanzhangwuu的博客
04-20 6157
在一些JDK中，我们使用import java.awt.*往往会出现is not accessible. 愿因是因为下面的module-info.java的存在不能访问awt。如下： 这时我们只需要把下面的module-info.java按Delete删除即可，awt类就能使用了。 ...
java初学--JFrame
twh233的算法blog
12-07 715
import java.awt.Color; import java.awt.Container; import java.awt.Window; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.SwingConstants; import javax.swing.WindowConstants;
JAVASE——全面总结JAVA中的GUI编程
kk的博客
03-01 686
前言 万字深入总结JAVA中的swing编程 文章目录前言1.简介2、AWT2.1、AWT介绍2.2 、组件和容器Frame面板Panel（解决关闭问题）布局管理器事件监听多个按钮共享一个事件输入框TextField监听简易计算器画笔鼠标监听窗口监听键盘监听3、Swing3.1、窗口3.2、弹窗3.3、标签3.4、面板3.5、按钮3.6、列表3.7、文本框 1.简介 GUI的核心技术 Swing和AWT 界面不美观 需要jre环境！ 可以写出自己心中想要的小工具 工作的时候，也可能需
JavaSE——访问控制权限、jar、单例和异常
LiLiLiLaLa的博客
07-22 314
1.包的定义及使用 包的本质实际上就属于一个文件夹，在项目开发中很难避免类名称重复的问题，如果所有的java文件都放在一个文件夹中，就有可能存在覆盖问题 1.1.包的导入 开发中使用包的定义之后，相当于把一个大的项目分别按照一定要求保存在了不同的包之中，但是这些程序类一定会发生互相调用的情况，这个时候就需要包的导入 类使用class和public class的区别： public class: ...
JAVA基础语言——JAVASE
jsqzy的博客
09-28 679
Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言（以下简称Java语言）和Java平台的总称。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java applet。另一方面，Java技术也不断更新。 其中Java有JAVAME、JAVASE、JavaEE组成。JAVASE目前也算是里面最基础的了。 Jav.
武汉理工大学面向对象与多线程综合实验——网络编程与多线程版本
mo_zhe的博客
01-13 2081
第四次验收：面向对象与多线程综合实验之网络编程与多线程版本 面向对象与多线程综合实验是一次大项目，总共分为4个部分进行验收，我将分成四个部分展示4个版本的项目工程。希望看到本文章的你，对你有所收获。 文章目录档案管理系统简介系统环境系统功能基于TCP的Java Socket连接过程基于TCP的Socket编程多线程Socket编程具体实现1.服务器端Server.java2.客户端StartI.javaClient.javaFilemanagement.javaMainGUI.javaMenuGUI.
「JavaSE」- GUI编程
WangJinDL的博客
04-25 769
GUI 编程 Swing和AWT 是java开发GUI常用的技术，但是由于外观不太美观, 组件数量偏少, 并且运行需要JRE环境(动不动就上百M的JRE包....), 所以没有流行起来。但是 ,建议简单的学习和了解。 组件(JTable,JList等)很多都是MVC的经典示范，学习GUI可以了解mvc架构。 工作时，有可能遇见需要维护N年前awt/swing写的软件 ,虽然可能性很小。 可以写一些自己使用用的软件，还是相当的方便。 swing是建立在awt基础上的。有必要
java Swing组件总结
Above the cloud
10-09 3266
第三个构造方法，是在第二个构造方法的基础上指定滚动条策略。通过图中还可以看出，Swing中有三个组件是继承了AWT的Window类，而不是继承自JComponent类，它们分别是JWindow、JFrame、和JDialog，这三个组件是Swing中的顶级容器，它们都需要依赖本地平台，因此被称为重量级组件。JComboBox组合框组件分为可编辑和不可编辑两种形式，对于不可编辑的组合框，用户只能在现有的选项列表中进行选择，而对于可编辑的组合框，用户既可以在现有的选项中选择，也可以自己输入新的内容。
Java文本框上的ActionEvent事件
热门推荐
cuihao0532的博客
12-05 1万+
三个概念：事件源， 监视器， 处理事件的接口 事件源能够产生事件的对象都可以成为事件源，如文本框、按钮、下拉式列表等。 事件源必须是一个对象，而且这个对象必须是Java认为能够发生事件的对象。 监视器一个对事件源进行监视，以便对发生的事件做出处理的对象。 事件源通过调用相应的方法将某个对象作为自己的监视器，例如。对于文本框，这个方法是addActionListener(监视器);对于获取了监视器的
Java基础--awt详解以及简单应用
qq_43842093的博客
05-21 6335
GUI 图形用户界面 CLI 命令行用户接口 Java为GUI提供的对象存在java.Awt和Javax.Swing两个包中. Java当中如何完成图形化界面的制作呢? AWT:abstract Window ToolKit.需要调用本地系统实现功能.属于重量级控件.依赖于平台.跨平台性不是特别好. Javax.Swing:在AWT基础上.建立一套图形化系统,提供更多组件,完全由java实现,增强了可移植性,属于轻量级控件.所以以后最好用Swing开发. 还有一个SWT外观包. Lable用来封装文字.C
java awt编程_java awt编程
weixin_31327207的博客
02-13 140
展开全部import java.awt.Frame;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public ...
java入门---方法操作实例之标签(Label)
luyaran的博客
05-22 7530
    Java 中的标签是为循环设计的，是为了在多重循环中方便的使用break 和coutinue。以下实例当在循环中使用 break 或 continue 循环时跳到指定的标签处：public class Main {    public static void main(String[] args) {        String strSearch = "This is the strin...
java awt 简单示例 GridLayout
我需要懂得努力
11-19 2682
import java.awt.Button; import java.awt.Frame; import java.awt.GridLayout; public class TestGridLayout { public static void main(String[] args) { new MyFrame3(); } } class MyFrame3 extends Fra
求助：import java.awt 出错
qq_43734950的博客
08-08 1万+
刚开始学java 安装的是最新版本的jdk12.0.2 不知道是什么原因无法使用java.awt 请问路径出错还是新版本取消了或者是其他问题 报错为：The package java.awt is not accessible 如果有大佬解答不胜感激 ...
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，提高系统资源利用率和响应速度。多线程涉及到进程和线程两个概念。进程是操作系统分配资源的基本单位，每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

DF10F-0001A

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

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

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

打赏作者

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

抵扣说明：

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

余额充值