基于JavaGUI开发的截图软件系统（截图；存储；编辑）

柔情只为你懂 2024-04-01 15:57 99阅读 0赞

毕业设计任务书 2  
摘要 6  
Abstract 7  
1． 绪论 10  
1.1课题背景 10  
1.2课题研究内容 10  
2．可行性分析及开发环境的选择 11  
2.1可行性分析 11  
2.1.1技术可行性 11  
2.1.2经济可行性 11  
2.1.3法律可行性 12  
2.1.4可行性结论 12  
2.2运行环境的选择 12  
2.3开发工具的选择 12  
2.4 B/S结构 13  
3．系统需求分析 15  
3.1业务需求 15  
3.2用户需求 15  
3.3性能需求 15  
4．系统设计 16  
4.1系统的设计目标 16  
4.2系统功能整体设计 16  
5．系统设计实现 19  
5.1系统主界面实现 19  
5.2系统截图实现 20  
5.3截图的编辑实现 26  
5.4截图的存储实现 37  
6．系统测试 41  
6.1截图软件系统测试 41  
6.1.1保存选项测试 41  
6.1.2复制到剪切板选项测试 41  
6.1.3编辑选项测试 42  
6.2测试评价 42  
结论 43  
参考文献 44  
致谢 45  
外文引用 46  
中文翻译 55

3．系统需求分析  
需求分析，是在计算机系统中创建一个新的项目或者将计算机里现在存在的项目时进行修改时描述新项目的概念，目标：涵盖范围和实现功能时所需要进行的准备工作。在软件项目设计工程中，需求分析是必不可少的至关重要的过程之一。顾客有哪些具体需求是在这个过程中，准确无误的传递给分析系统的人员和软件设计师。因为他们必须在确定了用户的需求后，才能够从用户的需求中分析、设计、得到适合解决方案来适应新系统。明确用户需求的软件功能是软件工程中需求分析的工作。  
需求分析的任务对现实世界中即将要进行操作的对象进行非常仔细认真的调查，并且保证非常了解原来系统在运行时的具体状态，准确的把握住用户的种种需要的功能及意见，之后设计基于原来系统基础的新系统功能。当然也需要明确系统需要的其他种种需求，因为软件的基本需求不单单只是功能需求，基本需求还包括其他几方面，一般来说，系统的设计与实现必须满足以下几个基本需求：（1）效果需要；（2）性能供应（3）能够上市与有保障（4）解决异常（5）协接的处理（6）限制（7）反方向的处理（8）日后有几率产生的需要。  
需求分析步骤： ⑴首先调查组织机构情况⑵然后调查各部门的业务活动情况⑶协助用户明确对新系统的各种要求⑷确定新系统的边界⑸分析系统功能⑹分析系统数据⑺编写分析报告。  
3.1业务需求  
能够实现对屏幕的随机截取，复制，保存以及添加文字等操作，便于用户对数据的处理。  
3.2用户需求  
用户给设计者提出的软件上的需求，是对产品的的要求。  
3.3性能需求  
指定的界面效果为系统效果，界面清晰，通俗易懂，操作简洁，用户使用时得心应手。  
4．系统设计  
系统设计，现如今软件设计必不可少的physical design。依据用户在需求分析时提出的系统功能需求进行设计，最终确定系统的逻辑要求、性能模型，在满足用户需求,依据用户所使用的的系统环境，拿出一个方案使得此项目能够在电脑的web环境上运行，通过系统的设计建立软件项目的物理模块。  
系统设计把软件项目按多级层次构造出来，并且将数据库和各个模块如何进行运行的流程构造出来作为此阶段的任务，系统设计是为了准确清晰的告诉所有用户软件系统的运行过程。系统设计又有:\[1\]总体设计；\[2\]详细设计，这个具体任务步骤。  
总体设计是为了处理设计的项目,在每个模块的分界线处作出详细的设计并设计各个小内容内部的上下等级的结构并且构建相应的,适合的数据库;详细设计能够将已经划分好的各个小内容的运行过程加以控制，以及内部算法的编写和构建相对稳定的信息结构。  
在进行系统设计时，通常有以下两种常用方法：\[1\]演绎法，\[2\]归纳法。  
如果设计一个程序时，需要使用归纳法，那么就要对以下方面保持警惕：第一尽自己最大的能力去系统资料,当然是同类的,时间段不限,包括目前的和以前的资料；第二以这些资料为依据,进行系统构造,以及运行,在对结果进行分析,根据需求分析里用户的功能需求选择相应的系统功能,之后对部分的系统(当然必须是同类型)进行更改，最后生成一个相对比较理想的项目。  
演绎法是由普通到特别的推理方法，即以客观的到处存在的规定和本质为出发点，依据众多的人员的广泛的知识和深邃的经历，从满足部分功能的模块集合中筛选出满足系统和用户所需要的功能的大量模块，本文转载自http://www.biyezuopin.vip/onews.asp?id=11214最后以某种特定的方式将这些模块组合在一起,最终满足需求分析中用户所需要功能的软件项目被设计出来了。  
4.1系统的设计目标  
自制Java截图工具将原来纯手动输入取代了，能够将所需要的信息以截图的形式保存下来，是操作更速度更方便。  
该软件的功能：  
随机获取屏幕指定区域；  
编辑（添加文字）截图；  
存储截图；  
4.2系统功能整体设计  
开发的总体设计：  
截图：根据提示，随机获取指定屏幕区域  
编辑：在图片上添加文字  
存储：指定存储目录将截图进行存储  
流程图请看下图：  
![在这里插入图片描述][90eae7a513a7483ebd2d0a8555eac2e5.png]

图4-2 程序流程图

package watermark;
    /**
     * CaptureScreen.java
     */
    import java.awt.*;
    import java.awt.datatransfer.DataFlavor;
    import java.awt.datatransfer.Transferable;
    import java.awt.datatransfer.UnsupportedFlavorException;
    import java.awt.event.*;
    import javax.swing.*;
    
    import watermark.MainFrame;
    
    import java.io.*;
    import javax.imageio.*;
    import java.awt.image.*;
    
    public class Main extends JFrame implements ActionListener {
        
        private JButton start,cancel;
        private JPanel c;
        private BufferedImage get;
        private JTabbedPane jtp;//一个放置很多份图片
        private int index;//一个一直会递增的索引,用于标认图片
        private JRadioButton system;//系统界面
        /** Creates a new instance of CaptureScreen */
        public Main() {
        
            super("截取屏幕");
            try{
        
                UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());//UIManager管理界面的类
            }catch(Exception e){
        
                e.printStackTrace();
            }
            initWindow();
            initOther();
        }
        private void initOther(){
        
            jtp=new JTabbedPane(JTabbedPane.TOP,JTabbedPane.SCROLL_TAB_LAYOUT);//JTabbedPane用于切换图片，显示子项
        }
        private void initWindow(){
        
            start=new JButton("开始截取");
            cancel=new JButton("退出");
            start.addActionListener(this);
            cancel.addActionListener(this);
            JPanel buttonJP=new JPanel();
            c=new JPanel(new BorderLayout());
            JLabel jl=new JLabel("截取屏幕", JLabel.CENTER);//JLable类作用是用来对齐，居中
            jl.setFont(new Font("黑体",Font.BOLD,40));
            jl.setForeground(Color.RED);
            c.add(jl,BorderLayout.CENTER);//将jl放入主面板中，并居中
            buttonJP.add(start);
            buttonJP.add(cancel);
            buttonJP.setBorder(BorderFactory.createTitledBorder("公共操作区"));
            JPanel jp=new JPanel();//放置一个单选按钮的面板
            jp.add(system=new JRadioButton("系统界面",true));
            system.addActionListener(this);
            jp.setBorder(BorderFactory.createTitledBorder("界面风格"));
            JPanel all=new JPanel();
            all.add(jp);
            all.add(buttonJP);
            this.getContentPane().add(c,BorderLayout.CENTER);
            this.getContentPane().add(all,BorderLayout.SOUTH);
            this.setSize(500,400);
            this.setLocationRelativeTo(null);//设置窗口相对于组件的位置
            this.setVisible(true);//显示窗口
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
        
        private void updates(){
        
            this.setVisible(true);
            if(get!=null){
        
                //如果索引是0,则表示一张图片都没有被加入过,
                //则要清除当前的东西,重新把tabpane放进来
                if(index==0){
        
                    c.removeAll();
                    c.add(jtp,BorderLayout.CENTER);
                }else{
        //否则的话,直接对tabpane添加面板就可以了
                    //就什么都不用做了
                }
                PicPanel pic=new PicPanel(get);
                jtp.addTab("图片"+(++index),pic);
                jtp.setSelectedComponent(pic);
                SwingUtilities.updateComponentTreeUI(c); // 调整LookAndFeel（javax.swing）
            }
        }
        
        private void doStart(){
        
            try{
        
                this.setVisible(false);//先隐藏窗口
                Thread.sleep(500);//睡500毫秒是为了让主窗完全不见
                Robot ro=new Robot(); // （通过本地操作）控制鼠标、键盘等实际输入源（java.awt）
                					//Robot类中有鼠标移动事件
                Toolkit tk=Toolkit.getDefaultToolkit(); // AWT组件的抽象父类（java.awt）
                					//绑定工具包，将不同界面合并到一起
                Dimension di=tk.getScreenSize();//Dimension封装长和宽
                Rectangle rec=new Rectangle(0,0,di.width,di.height);//坐标类，可以创建一个矩形
                BufferedImage bi=ro.createScreenCapture(rec);//访问图像数据缓冲区
                JFrame jf=new JFrame();
                Temp temp=new Temp(jf,bi,di.width,di.height); // 自定义的Temp类的对象
                jf.getContentPane().add(temp,BorderLayout.CENTER);
                jf.setUndecorated(true);//使标题一直存在
                jf.setSize(di);
                jf.setVisible(true);
                jf.setAlwaysOnTop(true);
            } catch(Exception e){
        
                e.printStackTrace();
            }
        }
        
        /**
        *公用的处理保存图片的方法
        */
        public  void doSave(BufferedImage get){
        
            try{
        
                if(get==null){
        
                    JOptionPane.showMessageDialog(this
                      , "图片不能为空!!", "错误", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                JFileChooser jfc=new JFileChooser(".");
                jfc.addChoosableFileFilter(new GIFfilter());
                jfc.addChoosableFileFilter(new BMPfilter());
                jfc.addChoosableFileFilter(new JPGfilter());
                jfc.addChoosableFileFilter(new PNGfilter());
                int i=jfc.showSaveDialog(this);//打开保存文件的对话框
                if(i==JFileChooser.APPROVE_OPTION){
        //获得选中的文件对象
                    File file=jfc.getSelectedFile();//获得选中的文件
                    String about="PNG";
                    String ext=file.toString().toLowerCase();
                    javax.swing.filechooser.FileFilter ff=jfc.getFileFilter();
                    if(ff instanceof JPGfilter){
        
                        if(!ext.endsWith(".jpg")){
        
                            String ns=ext+".jpg";
                            file=new File(ns);
                            about="JPG";
                        }
                    } else if(ff instanceof PNGfilter){
        
                        if(!ext.endsWith(".png")){
        
                            String ns=ext+".png";
                            file=new File(ns);
                            about="PNG";
                        }
                    }else if(ff instanceof BMPfilter){
        
                        if(!ext.endsWith(".bmp")){
        
                            String ns=ext+".bmp";
                            file=new File(ns);
                            about="BMP";
                        }
                    }else if(ff instanceof GIFfilter){
        
                        if(!ext.endsWith(".gif")){
        
                            String ns=ext+".gif";
                            file=new File(ns);
                            about="GIF";
                        }
                    }
                    if(ImageIO.write(get,about,file)){
        
                        JOptionPane.showMessageDialog(this,"保存成功！");
                    } else
                        JOptionPane.showMessageDialog(this,"保存失败！");
                }
            } catch(Exception exe){
        
                exe.printStackTrace();
            }
        }
        
        /** 
         *公共的处理把当前的图片加入剪帖板的方法
         */
        public void doCopy(final BufferedImage image){
        
            try{
        
                if(get==null){
        
                    JOptionPane.showMessageDialog(this
                      ,"图片不能为空!!","错误",JOptionPane.ERROR_MESSAGE);
                    return;
                } // java.awt.datatransfer（接口）
                Transferable trans = new Transferable(){
         // 内部类
                			//Transferable接口   不同介质间数据传输
                    public DataFlavor[] getTransferDataFlavors() {
        //返回一个DataFlavor数组
                        return new DataFlavor[] {
         DataFlavor.imageFlavor };//指定传输数据时的数据格式为图片数据
                    }
                    public boolean isDataFlavorSupported(DataFlavor flavor) {
        //判断当前传输数据的Transferable对象类型是否满足DataFlavor中的格式
                        return DataFlavor.imageFlavor.equals(flavor);
                    }
                    public Object getTransferData(DataFlavor flavor)//返回一个Transferable数据传输对象
                      throws UnsupportedFlavorException, IOException {
        
                        if(isDataFlavorSupported(flavor))
                            return image;
                        throw new UnsupportedFlavorException(flavor);
                    }
                };
                
                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(trans, null);//将Clipboard作为剪切板工具接口
                JOptionPane.showMessageDialog(this,"已复制到系统粘帖板!!");
            }catch(Exception exe){
        
                exe.printStackTrace();
                JOptionPane.showMessageDialog(this
                  ,"复制到系统粘帖板出错!!","错误",JOptionPane.ERROR_MESSAGE);
            }
        }
        
        //处理关闭事件
        private void doClose(Component c){
        
            jtp.remove(c);
            c=null;
            System.gc();
        }
        
        public void actionPerformed(ActionEvent ae){
        //动作事件，按下动作
            Object source=ae.getSource();
            if(source==start){
        
                doStart();
            } else if(source==cancel){
        
                System.exit(0);
            }
        }
        
        //一个内部类,它表示一个面板,一个可以被放进tabpane的面板
        //也有自己的一套处理保存和复制的方法
        private class PicPanel extends JPanel implements ActionListener{
        
            JButton save,copy,close,update;//表示保存,复制,关闭，编辑的按钮
            BufferedImage get;//得到的图片
            public PicPanel(BufferedImage get){
        
                super(new BorderLayout());
                this.get=get;
                initPanel();
            }
            private void initPanel(){
        
                save=new JButton("保存(S)");
                copy=new JButton("复制到剪帖板(C)");
                close=new JButton("关闭(X)");
                update=new JButton("编辑(U)");
                
                save.setMnemonic('S');
                copy.setMnemonic('C');
                close.setMnemonic('X');
                update.setMnemonic('U');
                
                JPanel buttonPanel=new JPanel();
                buttonPanel.add(copy);
                buttonPanel.add(save);
                buttonPanel.add(close);
                buttonPanel.add(update);
                
                JLabel icon=new JLabel(new ImageIcon(get));
                this.add(new JScrollPane(icon),BorderLayout.CENTER);
                this.add(buttonPanel,BorderLayout.SOUTH);
                save.addActionListener(this);
                copy.addActionListener(this);
                close.addActionListener(this);
                update.addActionListener(this);
            
            }
            public void actionPerformed(ActionEvent e) {
        
                Object source=e.getSource();
                if(source==save){
        
                    doSave(get);
                }else if(source==copy){
        
                    doCopy(get);
                }else if(source==close){
        
                    get=null;
                    doClose(this);
                }
                else if(source==update){
        
                	doSave(get);
                	this.setVisible(false);
                	MainFrame.getInstance();
                }
            }
        }
        
        //保存BMP格式的过滤器
        private class BMPfilter extends javax.swing.filechooser.FileFilter{
        
            public BMPfilter(){
        
            }
            public boolean accept(File file){
        
                if(file.toString().toLowerCase().endsWith(".bmp")||
                        file.isDirectory()){
        
                    return true;
                } else
                    return false;
            }
            public String getDescription(){
        
                return "*.BMP(BMP图像)";
            }
        }
        
        //保存JPG格式的过滤器
        private class JPGfilter extends javax.swing.filechooser.FileFilter{
        
            public JPGfilter(){
        
            }
            public boolean accept(File file){
        
                if(file.toString().toLowerCase().endsWith(".jpg")||
                        file.isDirectory()){
        
                    return true;
                } else
                    return false;
            }
            public String getDescription(){
        
                return "*.JPG(JPG图像)";
            }
        }
        
        //保存GIF格式的过滤器
        private class GIFfilter extends javax.swing.filechooser.FileFilter{
        
            public GIFfilter(){
        
            }
            public boolean accept(File file){
        
                if(file.toString().toLowerCase().endsWith(".gif")||
                        file.isDirectory()){
        
                    return true;
                } else
                    return false;
            }
            public String getDescription(){
        
                return "*.GIF(GIF图像)";
            }
        }
        
        //保存PNG格式的过滤器
        private class PNGfilter extends javax.swing.filechooser.FileFilter{
        
            public boolean accept(File file){
        
                if(file.toString().toLowerCase().endsWith(".png")||
                        file.isDirectory()){
        
                    return true;
                } else
                    return false;
            }
            public String getDescription(){
        
                return "*.PNG(PNG图像)";
            }
        }
        
        //一个临时类，用于显示当前的屏幕图像
        private class Temp extends JPanel implements MouseListener,MouseMotionListener{
        //鼠标单击，鼠标移动事件监听接口
            private BufferedImage bi;
            private int width,height;
            private int startX,startY,endX,endY,tempX,tempY;
            private JFrame jf;
            private Rectangle select=new Rectangle(0,0,0,0);//表示选中的区域
            private Cursor cs=new Cursor(Cursor.CROSSHAIR_CURSOR);//表示一般情况下的鼠标状态（十字线）
            private States current=States.DEFAULT;// 表示当前的编辑状态
            private Rectangle[] rec;//表示八个编辑点的区域
            //下面四个常量,分别表示谁是被选中的那条线上的端点
            public static final int START_X=1;
            public static final int START_Y=2;
            public static final int END_X=3;
            public static final int END_Y=4;
            private int currentX,currentY;//当前被选中的X和Y,只有这两个需要改变
            private Point p=new Point();//当前鼠标移的地点
            private boolean showTip=true;//是否显示提示.如果鼠标左键一按,则提示就不再显示了
            
            public Temp(JFrame jf,BufferedImage bi,int width,int height){
        
                this.jf=jf;
                this.bi=bi;
                this.width=width;
                this.height=height;
                this.addMouseListener(this);
                this.addMouseMotionListener(this);
                initRecs();
            }
            
            private void initRecs(){
        
                rec=new Rectangle[8];
                for(int i=0;i<rec.length;i++){
        
                    rec[i]=new Rectangle();
                }
            }
            
            public void paintComponent(Graphics g){
        
                g.drawImage(bi,0,0,width,height,this);
                g.setColor(Color.RED);
                g.drawLine(startX,startY,endX,startY);
                g.drawLine(startX,endY,endX,endY);
                g.drawLine(startX,startY,startX,endY);
                g.drawLine(endX,startY,endX,endY);
                int x=startX<endX?startX:endX;
                int y=startY<endY?startY:endY;
                select=new Rectangle(x,y,Math.abs(endX-startX),Math.abs(endY-startY));
                int x1=(startX+endX)/2;
                int y1=(startY+endY)/2;
                g.fillRect(x1-2,startY-2,5,5);
                g.fillRect(x1-2,endY-2,5,5);
                g.fillRect(startX-2,y1-2,5,5);
                g.fillRect(endX-2,y1-2,5,5);
                g.fillRect(startX-2,startY-2,5,5);
                g.fillRect(startX-2,endY-2,5,5);
                g.fillRect(endX-2,startY-2,5,5);
                g.fillRect(endX-2,endY-2,5,5);
                rec[0]=new Rectangle(x-5,y-5,10,10);
                rec[1]=new Rectangle(x1-5,y-5,10,10);
                rec[2]=new Rectangle((startX>endX?startX:endX)-5,y-5,10,10);
                rec[3]=new Rectangle((startX>endX?startX:endX)-5,y1-5,10,10);
                rec[4]=new Rectangle((startX>endX?startX:endX)-5,(startY>endY?startY:endY)-5,10,10);
                rec[5]=new Rectangle(x1-5,(startY>endY?startY:endY)-5,10,10);
                rec[6]=new Rectangle(x-5,(startY>endY?startY:endY)-5,10,10);
                rec[7]=new Rectangle(x-5,y1-5,10,10);
                if(showTip){
        
                    g.setColor(Color.CYAN);
                    g.fillRect(p.x,p.y,170,20);
                    g.setColor(Color.RED);
                    g.drawRect(p.x,p.y,170,20);
                    g.setColor(Color.BLACK);
                    g.drawString("请按住鼠标左键不放选择截图区",p.x,p.y+15);
                }
            }
            
            //根据东南西北等八个方向决定选中的要修改的X和Y的座标
            private void initSelect(States state){
        
                switch(state){
        
                    case DEFAULT:
                        currentX=0;
                        currentY=0;
                        break;
                    case EAST:
                        currentX=(endX>startX?END_X:START_X);
                        currentY=0;
                        break;
                    case WEST:
                        currentX=(endX>startX?START_X:END_X);
                        currentY=0;
                        break;
                    case NORTH:
                        currentX=0;
                        currentY=(startY>endY?END_Y:START_Y);
                        break;
                    case SOUTH:
                        currentX=0;
                        currentY=(startY>endY?START_Y:END_Y);
                        break;
                    case NORTH_EAST:
                        currentY=(startY>endY?END_Y:START_Y);
                        currentX=(endX>startX?END_X:START_X);
                        break;
                    case NORTH_WEST:
                        currentY=(startY>endY?END_Y:START_Y);
                        currentX=(endX>startX?START_X:END_X);
                        break;
                    case SOUTH_EAST:
                        currentY=(startY>endY?START_Y:END_Y);
                        currentX=(endX>startX?END_X:START_X);
                        break;
                    case SOUTH_WEST:
                        currentY=(startY>endY?START_Y:END_Y);
                        currentX=(endX>startX?START_X:END_X);
                        break;
                    default:
                        currentX=0;
                        currentY=0;
                        break;
                }
            }
            
            public void mouseMoved(MouseEvent me){
        
                doMouseMoved(me);
                initSelect(current); // current：当前状态（state）
                if(showTip){
        
                    p=me.getPoint();
                    repaint();
                }
            }
            
            //特意定义一个方法处理鼠标移动,是为了每次都能初始化一下所要选择的区域
            private void doMouseMoved(MouseEvent me){
        
                if(select.contains(me.getPoint())){
        
                    this.setCursor(new Cursor(Cursor.MOVE_CURSOR));
                    current=States.MOVE;
                } else{
        
                    States[] st=States.values();
                    for(int i=0;i<rec.length;i++){
        
                        if(rec[i].contains(me.getPoint())){
        
                            current=st[i];
                            this.setCursor(st[i].getCursor());
                            return;
                        }
                    }
                    this.setCursor(cs);
                    current=States.DEFAULT;
                }
            }
            
            public void mouseExited(MouseEvent me){
        //鼠标离开组件调用
            }
            
            public void mouseEntered(MouseEvent me){
        //鼠标进入组件调用
            }
            
            public void mouseDragged(MouseEvent me){
        //鼠标拖动事件
                int x=me.getX();
                int y=me.getY();
                // 分别处理一系列的（光标）状态（枚举值）
                if(current==States.MOVE){
        
                    startX+=(x-tempX);
                    startY+=(y-tempY);
                    endX+=(x-tempX);
                    endY+=(y-tempY);
                    tempX=x;
                    tempY=y;
                }else if(current==States.EAST||current==States.WEST){
        
                    if(currentX==START_X){
        
                        startX+=(x-tempX);
                        tempX=x;
                    }else{
        
                        endX+=(x-tempX);
                        tempX=x;
                    }
                }else if(current==States.NORTH||current==States.SOUTH){
        
                    if(currentY==START_Y){
        
                        startY+=(y-tempY);
                        tempY=y;
                    }else{
        
                        endY+=(y-tempY);
                        tempY=y;
                    }
                }else if(current==States.NORTH_EAST||current==States.NORTH_EAST||
                        current==States.SOUTH_EAST||current==States.SOUTH_WEST){
        
                    if(currentY==START_Y){
        
                        startY+=(y-tempY);
                        tempY=y;
                    }else{
        
                        endY+=(y-tempY);
                        tempY=y;
                    }
                    if(currentX==START_X){
        
                        startX+=(x-tempX);
                        tempX=x;
                    }else{
        
                        endX+=(x-tempX);
                        tempX=x;
                    }                
                }else{
        
                    startX=tempX;
                    startY=tempY;
                    endX=me.getX();
                    endY=me.getY();
                }
                this.repaint();
            }
            
            public void mousePressed(MouseEvent me){
        
                showTip=false;
                tempX=me.getX();
                tempY=me.getY();
            }
            
            public void mouseReleased(MouseEvent me){
        
                if(me.isPopupTrigger()){
         // 右键
                    if(current==States.MOVE){
        
                        showTip=true;
                        p=me.getPoint();
                        startX=0;
                        startY=0;
                        endX=0;
                        endY=0;
                        repaint();
                    } else{
         // 普通情况
                        jf.dispose();
                        updates();
                    }
                }
            }
            
            public void mouseClicked(MouseEvent me){
        //鼠标点击事件
                if(me.getClickCount()==2){
        
                    Point p=me.getPoint();
                    if(select.contains(p)){
        
                        if(select.x+select.width<this.getWidth()&&select.y+select.height<this.getHeight()){
        
                            get=bi.getSubimage(select.x,select.y,select.width,select.height);
                            jf.dispose();
                            updates();
                        }else{
        
                            int wid=select.width,het=select.height;
                            if(select.x+select.width>=this.getWidth()){
        
                                wid=this.getWidth()-select.x;
                            }
                            if(select.y+select.height>=this.getHeight()){
        
                                het=this.getHeight()-select.y;
                            }
                            get=bi.getSubimage(select.x,select.y,wid,het);
                            jf.dispose();
                            updates();
                        }
                    }
                }
            }
        }
        
        public static void main(String args[]) {
        
            SwingUtilities.invokeLater(new Runnable(){
        //创建线程
                public void run(){
        
                    new Main();
                }
            });
        }
    }
    
    //一些表示状态的枚举
    enum States{
        
        NORTH_WEST(new Cursor(Cursor.NW_RESIZE_CURSOR)),//表示西北角
        NORTH(new Cursor(Cursor.N_RESIZE_CURSOR)),
        NORTH_EAST(new Cursor(Cursor.NE_RESIZE_CURSOR)),
        EAST(new Cursor(Cursor.E_RESIZE_CURSOR)),
        SOUTH_EAST(new Cursor(Cursor.SE_RESIZE_CURSOR)),
        SOUTH(new Cursor(Cursor.S_RESIZE_CURSOR)),
        SOUTH_WEST(new Cursor(Cursor.SW_RESIZE_CURSOR)),
        WEST(new Cursor(Cursor.W_RESIZE_CURSOR)),
        MOVE(new Cursor(Cursor.MOVE_CURSOR)),
        DEFAULT(new Cursor(Cursor.DEFAULT_CURSOR));
        
        private Cursor cs;
        
        States(Cursor cs){
        
            this.cs=cs;
        }
        
        public Cursor getCursor(){
        
            return cs;
        }
    }

![在这里插入图片描述][187740b11db249299626fc00191875cd.png_pic_center]  
![在这里插入图片描述][ce684991bac540c5aa4d42a52fd52b7d.png_pic_center]  
![在这里插入图片描述][58d61b950548436fa9dceefa7c09ea86.png_pic_center]  
![在这里插入图片描述][1d817e33e51448089844ac45001b514e.png_pic_center]  
![在这里插入图片描述][ef04878570f94cb8b7337d2dc22ebacc.png_pic_center]  
![在这里插入图片描述][fecc4f4b98ed4327a7ec4e05b5b7776e.png_pic_center]  
![在这里插入图片描述][86d963cf90e9442b852e04cf41348932.png_pic_center]  
![在这里插入图片描述][2c90e4d9c4b242ac88c31cd89baabf9b.png_pic_center]  
![在这里插入图片描述][a9c8c54a19294c8aa1952dcb205570ad.png_pic_center]  
![在这里插入图片描述][e0d1001d6f3e43d2ba1047e312b0255b.png_pic_center]  
![在这里插入图片描述][1f449bd03de84198806409b1c88caaa2.png_pic_center]  
![在这里插入图片描述][c6563af251c34e33b8dd6e63c98911ea.png_pic_center]  
![在这里插入图片描述][e7187797edd9439a9c7146dee5a1cc76.png_pic_center]  
![在这里插入图片描述][6856f26b6a9f4bdd88fdbffbb0cd345e.png_pic_center]  
![在这里插入图片描述][88a48adf4bfb47bf8157b9937fb64eab.png_pic_center]  
![在这里插入图片描述][9d92c6702ff7451e8d01105b108ca8ab.png_pic_center]  
![在这里插入图片描述][d26b3e7ed18f40f4934604d65a80394a.png_pic_center]  
![在这里插入图片描述][70a6b7ff73d545a69d0e643e2f794f42.png_pic_center]  
![在这里插入图片描述][1f1bdf306f4b4de98c48b0ff6853d85a.png_pic_center]  
![在这里插入图片描述][e99ca86677db4e6ba560a7397b1f9326.png_pic_center]  
![在这里插入图片描述][5e4c1fc3a76440b99905bf174b4466fd.png_pic_center]

[90eae7a513a7483ebd2d0a8555eac2e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c5f6c2e1fab047d585daa9d58f7bfca3.png
[187740b11db249299626fc00191875cd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f7dfb18922964e26bd40ee8f664ae96b.png
[ce684991bac540c5aa4d42a52fd52b7d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0d1eb386f86146dba629ddcdfbf3b4f4.png
[58d61b950548436fa9dceefa7c09ea86.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d0fd77561cfa4ad9aefa9bd957c4bf4f.png
[1d817e33e51448089844ac45001b514e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/107b4ae312ac40d7986affd337d4e9b1.png
[ef04878570f94cb8b7337d2dc22ebacc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/21dcc8bf1c6d46a68448cd6e0b57a245.png
[fecc4f4b98ed4327a7ec4e05b5b7776e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/04d3cabecaa14d1aa642ec46d1e4845f.png
[86d963cf90e9442b852e04cf41348932.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d39337f0142f43268bf78fac3722c9b9.png
[2c90e4d9c4b242ac88c31cd89baabf9b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bcb798995acc4d2985711d04b1bc6b58.png
[a9c8c54a19294c8aa1952dcb205570ad.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d587eb015d9d4783a80425c3eb942b2f.png
[e0d1001d6f3e43d2ba1047e312b0255b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/17edc235fc4c495da0b267b79660fd1e.png
[1f449bd03de84198806409b1c88caaa2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/63aa40e4cf7f4a508e2c45afc70e4c9a.png
[c6563af251c34e33b8dd6e63c98911ea.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9c5f6f9aa4a340289ef7a4a17ae08633.png
[e7187797edd9439a9c7146dee5a1cc76.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a1cc05fa25634412ba7bee1c5d961e7b.png
[6856f26b6a9f4bdd88fdbffbb0cd345e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/964bbb33d78f497fb35b3430d5435611.png
[88a48adf4bfb47bf8157b9937fb64eab.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/45f3c269709c4c2b97dfb26a1ee4ac10.png
[9d92c6702ff7451e8d01105b108ca8ab.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c853fe99f7ad4dc0be4ae13d3770d6d9.png
[d26b3e7ed18f40f4934604d65a80394a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/dad801a9f07843a9803fc8ed5b601d99.png
[70a6b7ff73d545a69d0e643e2f794f42.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5a3172674b35411c9963d3440133372a.png
[1f1bdf306f4b4de98c48b0ff6853d85a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/626e228d28ad494d9e3c79073fd4dece.png
[e99ca86677db4e6ba560a7397b1f9326.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1389fcc4431e4479ad1919f508fa0ad7.png
[5e4c1fc3a76440b99905bf174b4466fd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9718122c0c564c119c7b3e9ca74cc4f3.png