Question

在我的应用程序中，我有一个主框架，用于固定底板。基板将容纳4个子面板。因此，假设第一个子面板出现，对数据进行处理，然后必须让第二个子面板出现，并将结果数据传递给它。第二个子面板必须进行另一次计算并将其传递给第三个，依此类推。我使用了卡布局，但我不知道如何在上一个面板的工作结束后看到面板。

这是一个简化版本：

public class LittleCardLayout{

    public static void main(String[] args) {
        new LittleCardLayout();
    }
    public LittleCardLayout(){
        JFrame frame = new JFrame("Test");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new BasePane());
        frame.setSize(800, 500);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

基本面板：

public class BasePane extends JPanel{
    public BasePane() {
            setLayout(new BorderLayout());
            CardLayout cl = new CardLayout();
            JPanel mainView = new JPanel(cl);

            mainView.add(new JPanel(), "empty");
            mainView.add(new TopPanel(), "toppanel");

            cl.show(mainView, "toppanel");
            add(mainView, BorderLayout.NORTH);
    }
}

子面板1：

public class TopPanel extends JPanel {
    int myValue = 23;
    int newVal;

    public TopPanel(){
         JButton btn = new JButton("Load Value");

        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
               newVal= 23-3;

               add(new BottomPanel(newVal), "toppanel");
            }
        });
        add(btn, BorderLayout.NORTH);
    }
}

子面板2：

public class BottomPanel extends JPanel {
    int num;
    JLabel myLabel = new JLabel();

    BottomPanel(int num){
        this.num = num;
        num = num*5;

        myLabel.setText(Integer.toString(num));
        add(myLabel);


    }
}

它必须像一步一步的过程一样工作。那么有什么想法将数据从一个面板传递到另一个面板并使它们彼此可见？这也是一步一步制定这种方法的正确方法，还是有更好的主意？

Answer 1

当每个面板完成它的处理时，它应该将通知发送回父面板，告诉它已完成。然后，父母小组将决定该做什么。

儿童小组不应该做出导航决定......

这是这个概念的基本例子。

它使用了两个interfaces（我是编码接口和限制实现细节暴露的粘合剂），一个处理东西的Processor和一个用于通知的ProcessListener Processor已完成的注册听众。

import java.awt.CardLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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 BasePane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class BasePane extends JPanel {

        private List<Processor> order;
        private CardLayout cardLayout;
        private ProcessListener processListener;

        public BasePane() {
            cardLayout = new CardLayout();
            setLayout(cardLayout);

            order = new ArrayList<>(4);

            processListener = new ProcessListener() {
                @Override
                public void processingComplete(Processor source) {
                    int nextIndex = order.indexOf(source) + 1;
                    System.out.println(nextIndex);
                    if (nextIndex < order.size()) {
                        Processor next = order.get(nextIndex);
                        System.out.println(next.getName());
                        cardLayout.show(BasePane.this, next.getName());
                        next.startProcessing();
                    }
                }
            };

            createProcessor("Meaning of life");
            createProcessor("Apple Pi");
            createProcessor("Thermal dynamics");
            createProcessor("Microsoft Word");

            Processor first = order.get(0);
            cardLayout.show(BasePane.this, first.getName());
            first.startProcessing();
        }

        protected Processor createProcessor(String name) {
            ProcessorPane pane = new ProcessorPane(name);
            pane.setProcessListener(processListener);
            add(pane, name);
            order.add(pane);
            return pane;
        }

    }

    public interface Processor {
        public void setProcessListener(ProcessListener listener);
        public ProcessListener getProcessListener();
        public void startProcessing();
        public String getName();
    }

    public interface ProcessListener {
        public void processingComplete(Processor source);
    }

    public class ProcessorPane extends JPanel implements Processor {

        private ProcessListener listener;

        public ProcessorPane(String name) {
            setName(name);
            setLayout(new GridBagLayout());
            add(new JLabel(name));
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        public void setProcessListener(ProcessListener listener) {
            this.listener = listener;
        }

        @Override
        public void startProcessing() {
            Timer timer = new Timer(1000, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    getProcessListener().processingComplete(ProcessorPane.this);
                }
            });
            timer.setRepeats(false);
            timer.start();
        }

        @Override
        public ProcessListener getProcessListener() {
            return listener;
        }

    }

}

可以扩展基本概念，以便Processor具有getValue和setValue（例如）方法，这些方法将允许控制器（在本例中为BasePane）将信息从一个Processor传递到另一个

这只是基于您当前方法的实现。我可能会使用一种将UI与处理分开的不同方法，因此您有一个“处理控制器”，它控制处理工作流程并将通知传回UI（或已注册的侦听器），关于它的当前状态操作

同样，你可以使用上述想法，但是使用轮询，定期从“处理控制器”请求信息......就像头顶的一些想法一样

如何在同一帧中一个接一个地运行面板

1 个答案: