如何在同一幀中一個接一個地運行面板

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（或已註冊的偵聽器），以瞭解它的當前狀態操作。

同樣，你可以使用上面的想法，而是使用輪詢，定期請求從「處理控制器」的信息......就像頭