java编写的截图软件，体积小功能强大完整代码

旧城等待， 2024-03-26 07:29 38阅读 0赞

今天为大家分享一个java语言的编写的截图软件，目前系统已经很完善，打开截图软件，系统在任务栏最小化运行，按快捷键实现截图，并且可以保存。整个系统界面漂亮，功能强大，有完整得源码，希望大家可以喜欢。喜欢的帮忙点赞和关注。一起编程、一起进步

## **开发环境** ##

开发语言为Java，开发环境Eclipse或者IDEA都可以，无需数据库。运行主程序，或者执行打开JAR文件即可以运行本程序。

## **系统框架** ##

利用JDK自带的SWING框架开发，下载。纯窗体模式，直接运行Main文件即可以。同时带有详细得设计文档。

## 系统主要功能 ##

### 研发背景 ###

本系统主要为自己开发的一个专门的截图软件，系统体积小，使用灵活。防止为了截图需要按照目前市面上的商业软件，甚至有些软件要收费。

### 实现的主要功能 ###

1 设置截图保存的目录，不设置的默认为F盘的截图文件夹

2 设置截图保存的图片格式，包含PNG、JGP、JPEG等格式

3 设置画笔的颜色

4设置画笔的粗细程度

5 设置程序自动启动方式。开机自动启动或者最小化显示

6 设置保存、复制、撤销、退出的快捷键

## 实现效果 ##

### 1 启动程序效果 ###

![2420cb046ddf8cb4f86d49b4e92397eb.png][]

### 2 截图程序参数设置 ###

![a46fb85435da8e5c4535f1b9a003638b.png][]

### 3 截图保存 ###

![aa26b677836b644c58c440d0cb017267.png][]

### 4 截图软件最小化设置 ###

![f04dd7f94d13617c494452c0db89875f.png][]

## 关键代码实现 ##

package screenshot;
    
    import java.awt.AWTException;
    import java.awt.EventQueue;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.KeyEvent;
    import java.awt.event.KeyListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.io.File;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.swing.ImageIcon;
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    import javax.swing.UIManager;
    import javax.swing.UnsupportedLookAndFeelException;
    import javax.swing.plaf.FontUIResource;
    
    import org.jb2011.lnf.beautyeye.BeautyEyeLNFHelper;
    
    import com.melloware.jintellitype.HotkeyListener;
    import com.melloware.jintellitype.JIntellitype;
    
    public class ScreenShotMainGUI extends JFrame implements ActionListener {
        // 定义热键标识，用于在设置多个热键时，在事件处理中区分用户按下的热键
        // 截图
        public static final int SSHOT_KEY_MARK = 0;
        // 退出程序
        public static final int EXIT_KEY_MARK = 3;
        // 退出当前截图
        public static final int EXIT_CURR_KEY_MARK = 4;
        // 保存
        public static final int SAVE_KEY_MARK = 1;
        // 复制到剪切板
        // public static final int COPY_KEY_MARK = 4;
        // 复制到剪切板并关闭截图
        public static final int CUT_KEY_MARK = 2;
        public JPanel jp1;
        public JButton button1, button2;
        public JFrame jf;
        public Screenshot accessibleScreenshot;
        public SshotUtils su = new SshotUtils();
        public static boolean fileExit = false;
        // 是否是刚启动设置(保证第一次启动设置的不同)
        public static boolean isJustSatrt = true;
        // 保证只能启动一个设置
        // public static boolean isOnlyOneSetup = true;
        // 是否打开了设置窗口
        public static boolean isOpenSetupJF = false;
        public SetupMsg sm;
        public SetupParams sp;
        public static String hotKey;
        // 所有的按键存入map
        public static Map<String, String> keyMap = new HashMap<String, String>();
        public static Map<String, String> keyMap2 = new HashMap<String, String>();
    
        public ScreenShotMainGUI() {
            // 初始化
            this.jf = this;
            initPro();
            initFirst();
            init();
        }
    
        // 初始化，检查是否已启动，是否最小化托盘
        private void initFirst() {
            // 是否已启动，启动则退出
            if (!su.checkSocket(sm.getPort() != 0 ? sm.getPort() : 12345)) {
                // JOptionPane.showMessageDialog(null, "程序已启动！请勿重复启动！", "提示消息",
                // JOptionPane.WARNING_MESSAGE);
                System.exit(0);
            }
    
        }
    
        // 设置最小化
        public void setJFMinSize() {
            // 是否最小化托盘
            try {
                // 若不支持托盘或者初始化失败,则提示
                if (!minimizeTray()) {
                    JOptionPane.showMessageDialog(null, "系统不支持托盘！", "提示消息", JOptionPane.WARNING_MESSAGE);
                    return;
                }
                dispose();
            } catch (AWTException e1) {
                e1.printStackTrace();
            }
        }
    
        // 初始化配置
        public void initPro() {
            // 初始化按键对照表
            su.initKeyMap();
            // 原理：首先判断exe所在目录是否存在隐藏的配置文件screentshotsetup.properties，
            // 如果存在，则读取此配置文件，如果不存在则生成一个默认的隐藏的配置文件
            // 实例化一个参数对象
            // 这个是用于设置具体参数
            sm = new SetupMsg();
            // 这个是用于显示具体参数
            sp = new SetupParams();
            File f = new File("screentshotsetup.properties");
            // 判断是否存在文件
            fileExit = su.isFileExit(f);
            if (fileExit) {
                // 获取默认配置信息
                try {
                    // 获取显示参数
                    sp = su.getDefaultMsg(f);
                    // 转化为使用参数
                    sm = su.trunSm(sp);
                } catch (Exception e1) {
                    sm = new SetupMsg();
                    e1.printStackTrace();
                }
            }
        }
    
        // 主方法
        public static void main(String[] args) {
            // 线程启动截图主程序
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    // 国人牛逼主题，值得学习
                    // 初始化字体
                    InitGlobalFont(new Font("微软雅黑", Font.PLAIN, 13));
                    // 设置本属性将改变窗口边框样式定义
                    // 系统默认样式 osLookAndFeelDecorated
                    // 强立体半透明 translucencyAppleLike
                    // 弱立体感半透明 translucencySmallShadow
                    // 普通不透明 generalNoTranslucencyShadow
                    BeautyEyeLNFHelper.frameBorderStyle = BeautyEyeLNFHelper.FrameBorderStyle.generalNoTranslucencyShadow;
                    // 设置主题为BeautyEye
                    try {
                        org.jb2011.lnf.beautyeye.BeautyEyeLNFHelper.launchBeautyEyeLNF();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 隐藏“设置”按钮
                    UIManager.put("RootPane.setupButtonVisible", false);
                    // 开启/关闭窗口在不活动时的半透明效果
                    // 设置此开关量为false即表示关闭之，BeautyEye LNF中默认是true
                    BeautyEyeLNFHelper.translucencyAtFrameInactive = false;
                    // 设置BeantuEye外观下JTabbedPane的左缩进
                    // 改变InsetsUIResource参数的值即可实现
                    UIManager.put("TabbedPane.tabAreaInsets", new javax.swing.plaf.InsetsUIResource(3, 20, 2, 20));
                    // UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                    new ScreenShotMainGUI();
                }
            });
        }
    
        // font
        private static void InitGlobalFont(Font font) {
            FontUIResource fontRes = new FontUIResource(font);
            for (Enumeration<Object> keys = UIManager.getDefaults().keys(); keys.hasMoreElements();) {
                Object key = keys.nextElement();
                Object value = UIManager.get(key);
                if (value instanceof FontUIResource) {
                    UIManager.put(key, fontRes);
                }
            }
        }
    
        // 初始化
        private void init() {
            jp1 = new JPanel();
            jp1.setLayout(null);
    
            button1 = new JButton("截图");
            button1.addActionListener(this);
            button1.setBounds(1, 0, 100, 48);
            jp1.add(button1);
            button1.setEnabled(true);
    
            ImageIcon sshotSet = new ImageIcon(getClass().getResource("setup.png"));
            button2 = new JButton(sshotSet);
            button2.addActionListener(this);
            button2.setBounds(102, 0, 49, 47);
            jp1.add(button2);
            button2.setEnabled(true);
    
            this.add(jp1);
            this.setSize(162, 86);
            this.setLocationRelativeTo(null);
            this.setVisible(true);
            this.setResizable(false);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            ImageIcon i = new ImageIcon(getClass().getResource("screenshot.png"));
            this.setIconImage(i.getImage());
    
            // 取出sm中list，进行处理并返回第二个参数和第三个参数
            int[] sskm = su.proParamList(sm.getSshkList(), SSHOT_KEY_MARK);
            int[] skm = su.proParamList(sm.getShkList(), SAVE_KEY_MARK);
            int[] ckm = su.proParamList(sm.getChkList(), CUT_KEY_MARK);
            int[] ekm = su.proParamList(sm.getEhkList(), EXIT_KEY_MARK);
            int[] eckm = su.proParamList(sm.getCchkList(), EXIT_CURR_KEY_MARK);
    
            // 第一步：注册热键，第一个参数表示该热键的标识，第二个参数表示组合键，如果没有则为0，第三个参数为定义的主要热键
            // 截图
            JIntellitype.getInstance().registerHotKey(SSHOT_KEY_MARK, sskm[0], sskm[1]);
            // 保存
            JIntellitype.getInstance().registerHotKey(SAVE_KEY_MARK, skm[0], skm[1]);
            // 复制到剪切板并关闭截图
            JIntellitype.getInstance().registerHotKey(CUT_KEY_MARK, ckm[0], ckm[1]);
            // 退出程序
            JIntellitype.getInstance().registerHotKey(EXIT_KEY_MARK, ekm[0], ekm[1]);
            // 取消当前截图
            JIntellitype.getInstance().registerHotKey(EXIT_CURR_KEY_MARK, eckm[0], eckm[1]);
    
            // JIntellitype.getInstance()
            // 第二步：添加热键监听器
            JIntellitype.getInstance().addHotKeyListener(new HotkeyListener() {
                public void onHotKey(int markCode) {
                    switch (markCode) {
                    case SSHOT_KEY_MARK:
                        if (ScreenShotMainGUI.isOpenSetupJF == true) {
                            // 设置界面打开时，禁止截图程序
                            su.proKeyBeforeSshot(SSHOT_KEY_MARK, sm);
                            return;
                        }
                        startScreenShot();
                        break;
                    case EXIT_KEY_MARK:
                        if (ScreenShotMainGUI.isOpenSetupJF == true) {
                            // 设置界面打开时，禁止截图程序
                            su.proKeyBeforeSshot(EXIT_KEY_MARK, sm);
                            return;
                        }
                        System.exit(0);
                        break;
                    case EXIT_CURR_KEY_MARK:
                        if (ScreenShotMainGUI.isOpenSetupJF == true) {
                            // 设置界面打开时，禁止截图程序
                            su.proKeyBeforeSshot(EXIT_CURR_KEY_MARK, sm);
                            return;
                        }
                        exitCurrScreenShot();
                        break;
                    case SAVE_KEY_MARK:
                        if (ScreenShotMainGUI.isOpenSetupJF == true) {
                            // 设置界面打开时，禁止截图程序
                            su.proKeyBeforeSshot(SAVE_KEY_MARK, sm);
                            return;
                        }
                        saveCurrSshot();
                        break;
                    case CUT_KEY_MARK:
                        if (ScreenShotMainGUI.isOpenSetupJF == true) {
                            // 设置界面打开时，禁止截图程序
                            su.proKeyBeforeSshot(CUT_KEY_MARK, sm);
                            return;
                        }
                        cutCurrSshot();
                        break;
                    }
                }
            });
    
            // 监听界面关闭事件
            this.addWindowListener(new WindowAdapter() {
                // 当最小化时
                public void windowIconified(WindowEvent e) {
                    setJFMinSize();
                }
            });
    
            // 是否最小化托盘
            if (sm.isStartMinSize()) {
                setJFMinSize();
            }
    
        }
    
        // 复制
        protected void cutCurrSshot() {
            if (accessibleScreenshot != null) {
                try {
                    accessibleScreenshot.copyClipImage();
                    exitCurrScreenShot();
                } catch (IOException e) {
                    e.printStackTrace();
                    JOptionPane.showMessageDialog(null, "复制失败！", "提示消息", JOptionPane.WARNING_MESSAGE);
                }
            }
        }
    
        // 保存当前截图
        protected void saveCurrSshot() {
            if (accessibleScreenshot != null) {
                try {
                    accessibleScreenshot.saveImage();
                    exitCurrScreenShot();
                } catch (IOException e) {
                    e.printStackTrace();
                    JOptionPane.showMessageDialog(null, "保存失败！", "提示消息", JOptionPane.WARNING_MESSAGE);
                }
            }
        }
    
        // 退出当前截图
        public void exitCurrScreenShot() {
            if (accessibleScreenshot != null) {
                accessibleScreenshot.cancel();
                if (accessibleScreenshot.tools != null) {
                    accessibleScreenshot.tools.dispose();
                }
            }
        }
    
        // 最小化系统托盘
        protected boolean minimizeTray() throws AWTException {
            MinimizeTrayJPanel mtj = new MinimizeTrayJPanel(this);
            return mtj.init();
        }
    
        public void startScreenShot() {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    try {
                        // 先判断是否存在当前截图
                        // 有则取消
                        exitCurrScreenShot();
                        accessibleScreenshot = new Screenshot(jf, false, sm);
                        accessibleScreenshot.setVisible(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    
        @Override
        public void actionPerformed(ActionEvent e) {
            // 监听截图按钮
            if (e.getSource().equals(button1)) {
                startScreenShot();
            }
            // 监听设置按钮
            if (e.getSource().equals(button2)) {
                // false表示已打开，true才可以打开
                if (!ScreenShotMainGUI.isOpenSetupJF) {
                    ScreenShotMainGUI.isOpenSetupJF = true;
                    SetupJF sjp = new SetupJF();
                }
            }
        }
    
    }

## 项目总结 ##

开发一套系统，最重要的是细心，并不是一定要做到面面俱到，在准备工作中要正确分析社会需求了解现实应用，画出流程图，把大体框架做好，然后再逐一细化。我们不可能做到面面俱到，但一定要做到步步扎实，作为一个程序编程人员，要保持清醒的头脑，以现实为依据，让自己的每一行代码都能实现自己的意义。 通过这次项目开发，我收获的不仅仅是课程上的知识得到实际应用，还有编程的基本习惯和开发系统时应注意的流程。

[2420cb046ddf8cb4f86d49b4e92397eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1d4a14bf35ab49ed90ecf65346c544ff.png
[a46fb85435da8e5c4535f1b9a003638b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/00a3d0558cde4b4b8a2c4bed935e7144.png
[aa26b677836b644c58c440d0cb017267.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ab6a220bcdff4d9e844c7ceba5fedd9f.png
[f04dd7f94d13617c494452c0db89875f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/fd453a3fca8e4483b3a2ff409153a17e.png