Java 重新喷漆，但不重新喷漆每个组件

我有一个包含jframe的应用程序，这个jframe然后添加一个包含图像的jpanel。jpanel将在给定的时间内显示，然后从jframe中删除并添加另一个jpanel

我想在图像之间淡入淡出，我是用定时器完成的

private void fadeOut() {
    ActionListener fadeOutAc = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            opacity += 10;
            if (opacity >= 255) {
                opacity = 255;
                fadeOutT.stop();

            }
            repaint();
        }
    };

    fadeOutT = new Timer(20, fadeOutAc);
    fadeOutT.start();
}

private void fadeIn() {
    ActionListener fadeInAc = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            opacity -= 10;
            if (opacity <= 0) {
                opacity = 0;
                fadeInT.stop();
            }
            repaint();

        }
    };
    fadeInT = new Timer(10, fadeInAc);
    fadeInT.setInitialDelay(200);
    fadeInT.start();

}

public void paint(Graphics g) {
    super.paintComponent(g);
    g.setColor(new Color(picColor.getRed(), picColor.getGreen(), picColor.getBlue(), opacity));
    g.fillRect(0, 0, presWin.getWidth(), presWin.getHeight());
}

private void fadeOut（）{
ActionListener fadeOutAc=新建ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
不透明度+=10；
如果（不透明度>=255）{
不透明度=255；
fadeout.stop（）；
}
重新油漆（）；
}
};
淡出=新定时器（20，淡出）；
fadeout.start（）；
}
私人空间{
ActionListener fadeInAc=新建ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
不透明度-=10；
如果（不透明度完全正常，将函数移动到
JFrame
并调用
repaint
函数实际上会调用JFrame的
repaint

我认为最好的解决方案是将panel作为参数传递给
fadeIn
和
fadeOut
函数，并调用其
repaint
方法，例如fadeIn:

private void fadeIn(JPanel panelParam) {
    ActionListener fadeInAc = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            opacity -= 10;
            if (opacity <= 0) {
                opacity = 0;
                fadeInT.stop();
            }
            panelParam.repaint(); // here call repaint of the panel.

        }
    };
    fadeInT = new Timer(10, fadeInAc);
    fadeInT.setInitialDelay(200);
    fadeInT.start();

}

private void fadeIn（JPanel panelParam）{
ActionListener fadeInAc=新建ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
不透明度-=10；
如果（不透明度对我来说，当你似乎想要的是一个可以淡入淡出内容的容器时，将功能放在
JFrame
中似乎有点愚蠢。这样你就可以将责任隔离到一个容器/类上，这个容器/类可以以你想要的任何方式放置或使用到UI的其余部分

基本上，此示例使用
FadingPane
（基于
JPanel
）来控制淡入过程，但我将
JLabel
放在其上，它保存实际图像

淡入淡出通过使用AlphaComposite来控制，这意味着该面板实际上会淡入淡出，而不仅仅是改变填充颜色；）

还有一个
FadingListener
，它提供有关淡入过程的附加通知，真正感兴趣的是
fadeoutdicomplete
，因此您可以切换图像并将面板淡入，但您永远不知道

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private JLabel label;
        private FadingPane fadingPane;

        private File[] pictures;
        private int index;

        public TestPane() {
            // Just for show 
            setBackground(Color.RED);
            fadingPane = new FadingPane(new FadeListener() {
                @Override
                public void fadeDidStart(FadingPane panel) {
                }

                @Override
                public void fadeDidStop(FadingPane panel) {
                }

                @Override
                public void fadeOutDidComplete(FadingPane panel) {
                    nextPicture();
                    fadingPane.fadeIn();
                }

                @Override
                public void fadeInDidComplete(FadingPane panel) {
                }
            });
            setLayout(new BorderLayout());
            fadingPane.setLayout(new BorderLayout());
            label = new JLabel();
            fadingPane.add(label);

            add(fadingPane);

            JButton next = new JButton("Next");
            add(next, BorderLayout.SOUTH);
            next.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    fadingPane.fadeOut();
                }
            });

            pictures = new File("/Volumes/Disk02/Dropbox/MegaTokyo/thumnails").listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    String name = pathname.getName().toLowerCase();
                    return name.endsWith(".jpg") || name.endsWith(".png");
                }
            });
            nextPicture();
        }

        protected void nextPicture() {
            index++;
            if (index >= pictures.length) {
                index = 0;
            }
            try {
                BufferedImage img = ImageIO.read(pictures[index]);
                label.setIcon(new ImageIcon(img));
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }

    public interface FadeListener {
        public void fadeDidStart(FadingPane panel);
        public void fadeDidStop(FadingPane panel);
        public void fadeOutDidComplete(FadingPane panel);
        public void fadeInDidComplete(FadingPane panel);
    }

    public class FadingPane extends JPanel {

        private float delta;
        private float alpha = 1f;
        private Timer timer;

        private FadeListener fadeListener;

        public FadingPane(FadeListener fadeListener) {
            this.fadeListener = fadeListener;
            // This is important, as we may not always be opaque
            // and we don't want to stuff up the painting process
            setOpaque(false);

            timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    float alpha = getAlpha() + delta;
                    if (alpha < 0.001f) {
                        alpha = 0f;
                        timer.stop();
                        fadeListener.fadeOutDidComplete(FadingPane.this);
                    } else if (alpha >= 1.0f) {
                        alpha = 1.0f;
                        timer.stop();
                        fadeListener.fadeInDidComplete(FadingPane.this);
                    }
                    setAlpha(alpha);
                }
            });
        }

        public float getAlpha() {
            return alpha;
        }

        public void setAlpha(float value) {
            if (alpha != value) {
                this.alpha = Math.min(1.0f, Math.max(0.0f, value));
                repaint();
            }
        }

        @Override
        public void paint(Graphics g) {
            // I don't normally recomamned overriding paint, but in this case,
            // I want to affect EVERYTHING that might be added to this panel
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.setComposite(AlphaComposite.SrcOver.derive(getAlpha()));
            super.paint(g2d);
            g2d.dispose();
        }

        public void fadeIn() {
            timer.stop();
            fadeListener.fadeDidStop(FadingPane.this);
            delta = 0.05f;
            timer.restart();
            fadeListener.fadeDidStart(FadingPane.this);
        }

        public void fadeOut() {
            timer.stop();
            fadeListener.fadeDidStop(FadingPane.this);
            delta = -0.05f;
            timer.restart();
            fadeListener.fadeDidStart(FadingPane.this);
        }

    }

}


导入java.awt.AlphaComposite；
导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.FileFilter；
导入java.io.IOException；
导入javax.imageio.imageio；
导入javax.swing.ImageIcon；
导入javax.swing.JButton；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
公开课考试{
公共静态void main（字符串[]args）{
新测试（）；
}
公开考试（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
例如printStackTrace（）；
}
JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类TestPane扩展了JPanel{
私人标签；
私人淡定窗格淡定窗格；
私有文件[]图片；
私有整数索引；
公共测试窗格（）{
//只是作秀
挫折地面（颜色：红色）；
fadingPane=新的fadingPane（新的FadeListener（）{
@凌驾
公共无效FadEdStart（FadingPane面板）{
}
@凌驾
公共无效fadeDidStop（FadingPane面板）{
}
@凌驾
公共无效渐减完成（渐减窗格面板）{
nextPicture（）；
fadingPane.fadeIn（）；
}
@凌驾
公共无效fadeInDidComplete（FadingPane面板）{
}
});
setLayout（新的BorderLayout（））；
setLayout（新的BorderLayout（））；
label=新的JLabel（）；
fadingPane.add（标签）；
添加（淡入淡出窗格）；
JButton next=新JButton（“next”）；
添加（下一步，BorderLayout.SOUTH）；
next.addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
fadingPane.fadeOut（）；
}
});
图片=新文件（“/Volumes/Disk02/Dropbox/MegaTokyo/thumnails”）.listFiles（新文件过滤器（）{
@凌驾
公共布尔接受（文件路径名）{
String name=pathname.getName（）.toLowerCase（）；
返回name.endsWith（“.jpg”）| name.endsWith（“.png”）；
}
});
nextPicture（）；
}
受保护的void nextPicture（）{
索引++；
如果（索引>=图片长度）{
指数=0；
}
试一试{
BuffereImage img=图像IO.read（图片[索引]）；
标签设置图标（ne）