java实现简单泡泡屏保动画及点击变实心泡泡

淡淡的烟草味﹌ 2022-05-24 00:52 160阅读 0赞

## 工具类 ##

package com.egeo.jframetext;
    
    import java.awt.*;
    import java.awt.geom.Ellipse2D;
    
    import java.lang.InterruptedException;
    
    public class AlgoVisHelper { 
    
        private AlgoVisHelper(){}
    
        public static void strokeCircle(Graphics2D g, int x, int y, int r){
    
            Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
            g.draw(circle);
        }
    
        public static void fillCircle(Graphics2D g, int x, int y, int r){
    
            Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
            g.fill(circle);
        }
    
        public static void setColor(Graphics2D g, Color color){
            g.setColor(color);
        }
    
        public static void setStrokeWidth(Graphics2D g, int w){
            int strokeWidth = w;
            g.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        }
    
        public static void pause(int t) {
            try {
                Thread.sleep(t);
            }
            catch (InterruptedException e) {
                System.out.println("Error sleeping");
            }
        }
    
    }

## 具体绘制类（视图层） ##

package com.egeo.jframetext;
    
    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.RenderingHints;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    
    public class AlgoFrame extends JFrame{ 
    
        private int canvasWidth;
        private int canvasHeight;
    
        public AlgoFrame(String title, int canvasWidth, int canvasHeight){
            //设置标题
            super(title);
            //设置窗口宽度
            this.canvasWidth = canvasWidth;
            //设置窗口高度
            this.canvasHeight = canvasHeight;
    
            AlgoCanvas canvas = new AlgoCanvas();
            setContentPane(canvas);
            pack();
    
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setResizable(false);
    
            setVisible(true);
        }
    
        public AlgoFrame(String title){
    
            this(title, 1024, 768);
        }
    
        public int getCanvasWidth(){
       return canvasWidth;}
        public int getCanvasHeight(){
       return canvasHeight;}
        //public JPanel getCanvas(){return canvas;}
    
        // data
        private Circle[] circles;
        public void render(Circle[] circles){
            this.circles = circles;
            repaint();
        }
    
        private class AlgoCanvas extends JPanel{ 
    
            public AlgoCanvas(){
                // 双缓存
                super(true);
            }
    
            @Override
            public void paintComponent(Graphics g) {
                super.paintComponent(g);
    
                Graphics2D g2d = (Graphics2D)g;
    
                // 抗锯齿
                RenderingHints hints = new RenderingHints(
                        RenderingHints.KEY_ANTIALIASING,
                        RenderingHints.VALUE_ANTIALIAS_ON);
                hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
                g2d.addRenderingHints(hints);
    
                // 具体绘制
                AlgoVisHelper.setStrokeWidth(g2d,1);
                AlgoVisHelper.setColor(g2d, Color.RED);
                for(Circle circle: circles)
                    //判断是画空心圆还是实心圆
                    if(circle.isFilled)
                        AlgoVisHelper.fillCircle(g2d, circle.x, circle.y, circle.getR());
                    else
                        AlgoVisHelper.strokeCircle(g2d, circle.x, circle.y, circle.getR());
            }
    
            @Override
            public Dimension getPreferredSize(){
                return new Dimension(canvasWidth, canvasHeight);
            }
        }
    }

## 圆实体类及边缘碰撞逻辑处理 ##

package com.egeo.jframetext;
    
    import java.awt.Point;
    
    public class Circle { 
    
        public int x, y;
        private int r;
        public int vx, vy;
        public boolean isFilled = false;
    
        public Circle(int x, int y, int r, int vx, int vy){
            this.x = x;
            this.y = y;
            this.r = r;
            this.vx = vx;
            this.vy = vy;
        }
    
        public int getR() {
            return r;
        }
    
        public void move(int minx, int miny, int maxx, int maxy){
            x += vx;
            y += vy;
    
            checkCollision(minx, miny, maxx, maxy);
        }
    
        private void checkCollision(int minx, int miny, int maxx, int maxy){
    
            if(x - r < minx) { x = r;        vx = -vx; }
            if(x + r >= maxx){ x = maxx - r; vx = -vx; }
            if(y - r < miny) { y = r;        vy = -vy; }
            if(y + r >= maxy){ y = maxy - r; vy = -vy; }
        }
    
        public boolean contain(Point p){
            return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y) <= r * r;
        }
    
    }

## 控制层 ##

package com.egeo.jframetext;
    
    import java.awt.EventQueue;
    import java.awt.event.KeyAdapter;
    import java.awt.event.KeyEvent;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    
    public class AlgoVisualizer { 
    
        private Circle[] circles;
        private AlgoFrame frame;
        private boolean isAnimated = true;
    
        public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
    
            // 初始化数据
            circles = new Circle[N];
            int R = 50;
            for(int i = 0 ; i < N ; i ++){
                int x = (int)(Math.random()*(sceneWidth-2*R)) + R;
                int y = (int)(Math.random()*(sceneHeight-2*R)) + R;
                int vx = (int)(Math.random()*11) - 5;
                int vy = (int)(Math.random()*11) - 5;
                circles[i] = new Circle(x, y, R, vx, vy);
            }
    
            // 初始化视图
            EventQueue.invokeLater(() -> {
                frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
                //监控键盘事件
                frame.addKeyListener(new AlgoKeyListener());
                //监控鼠标事件
                frame.addMouseListener(new AlgoMouseListener());
                new Thread(() -> {
                    run();
                }).start();
            });
        }
    
        // 动画逻辑
        private void run(){
    
            while(true){
                // 绘制数据
                frame.render(circles);
                AlgoVisHelper.pause(20);
    
                // 更新数据
                if(isAnimated)
                    for(Circle circle : circles)
                        circle.move(0, 0, frame.getCanvasWidth(), frame.getCanvasHeight());
            }
        }
    
        private class AlgoKeyListener extends KeyAdapter{ 
    
            @Override
            public void keyReleased(KeyEvent event){
                if(event.getKeyChar() == ' ')
                    isAnimated = !isAnimated;
            }
        }
    
        private class AlgoMouseListener extends MouseAdapter{ 
    
            @Override
            public void mousePressed(MouseEvent event){
                //鼠标点击坐标减去窗口标题栏高度
                event.translatePoint(0,
                        -(frame.getBounds().height - frame.getCanvasHeight()));
    
                for(Circle circle : circles)
                    //判断鼠标点击是否在圆内
                    if(circle.contain(event.getPoint()))
                        circle.isFilled = !circle.isFilled;
            }
        }
    
        public static void main(String[] args) {
    
            int sceneWidth = 800;
            int sceneHeight = 800;
            int N = 10;
    
            AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);
        }
    }

“\`

## 效果图片 ##

![这里写图片描述][70]

[70]: /images/20220524/3e6b90a78041440388af9fac43c66658.png