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

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它处理的东西，它是用来通知注册监听器，该Processor已经完成了ProcessListener。

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（或已注册的侦听器），以了解它的当前状态操作。

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