如何在 JPanel 类之间传递变量？

Question

我有一个 JTabbedPane 和两个 JPanel，需要保留在不同的类中。在 PageOne 中，我希望能够通过单击添加按钮来增加 MyInteger，然后我希望能够通过单击那里的按钮在 PageTwo 中打印该整数。它在 PageOne 中打印正确的值，但当我将其传递给 PageTwo 类并在那里打印时，它会打印 0。

如何传递值，以便在单击两个 JPanel 中的按钮时打印正确的值？我认为这与我从 PageOne 继承的方式有关，但找不到解决我的问题的更改它的方法。

主类：

import javax.swing.*;

public class MyJFrame {

    PageOne pageOne;
    PageTwo pageTwo;

    public MyJFrame() {

        JFrame f = new JFrame();

        pageOne = new PageOne();
        pageTwo = new PageTwo();

        JTabbedPane jTabbedPane = new JTabbedPane();

        jTabbedPane.addTab("Page One", pageOne);
        jTabbedPane.addTab("Page Two", pageTwo);

        f.add(jTabbedPane);
        f.setSize(200,120);
        f.setVisible(true);
    }

    public static void main(String[] args) throws InterruptedException {
        new MyJFrame();

    }
}

JPanel一：

import javax.swing.*;

public class PageOne extends JPanel {

    public Integer myInteger = 0;
    public JButton add;

    public PageOne() {

        add = new JButton();
        add.setText("Increment number");

        add(add);

        add.addActionListener(actionEvent -> {
            myInteger++;
            printOne();
        });

    }

    public void printOne() {
        System.out.println("Page One:" + myInteger);
    }

}

JPanel二：

import javax.swing.*;

public class PageTwo extends JPanel {

    PageOne  pageOneRef = new PageOne();
    public JButton button;

    public PageTwo() {

        JPanel panel = new JPanel();

        button = new JButton("Click me");

        panel.add(button);
        add(panel);

        button.addActionListener(e -> printTwo());
    }

    public void printTwo() {
        System.out.println("Page Two:" + pageOneRef.myInteger);
    }
}

Answer 1

基本答案是，您需要某种可以在两个组件之间共享的“容器”。这通常是通过使用某种“模型”来实现的。

请参阅：

• 模型-视图-控制器
• 观察者模式
• 编写事件监听器，

了解下面提供的概念的概述

可运行示例

import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

public class Main {

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

    public Main() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();

                DefaultIntegerModel model = new DefaultIntegerModel();
                JTabbedPane tabbedPane = new JTabbedPane();
                tabbedPane.addTab("Page One", new PageOne(model));
                tabbedPane.addTab("Page Two", new PageTwo(model));

                frame.add(tabbedPane);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public interface IntegerModel {
        public interface Observer {
            public void valueDidChange(IntegerModel source, int value);
        }
        public int getValue();
        public void addObserver(Observer observer);
        public void removeObserver(Observer observer);
    }

    public interface MutableIntegerModel extends IntegerModel {

        public void setValue(int value);
    }

    public class DefaultIntegerModel implements MutableIntegerModel {

        private int value;

        private List<Observer> observers;

        public DefaultIntegerModel() {
            this(0);
        }

        public DefaultIntegerModel(int value) {
            this.value = value;
            observers = new ArrayList<Observer>(8);
        }

        @Override
        public void setValue(int value) {
            this.value = value;
            fireValueDidChange(value);
        }

        @Override
        public int getValue() {
            return value;
        }

        @Override
        public void addObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        protected void fireValueDidChange(int value) {
            for (Observer observer : observers) {
                observer.valueDidChange(this, value);
            }
        }
    }

    public class PageOne extends JPanel {

        public JButton add;

        private MutableIntegerModel model;

        public PageOne(MutableIntegerModel model) {
            this.model = model;

            add = new JButton();
            add.setText("Increment number");

            add(add);

            add.addActionListener(actionEvent -> {
                model.setValue(model.getValue() + 1);
                printOne();
            });

        }

        public void printOne() {
            System.out.println("Page One:" + model.getValue());
        }

    }

    public class PageTwo extends JPanel {

        private JButton button;
        private JLabel label;
        private IntegerModel model;

        public PageTwo(IntegerModel model) {
            this.model = model;
            model.addObserver(new IntegerModel.Observer() {
                @Override
                public void valueDidChange(IntegerModel source, int value) {
                    System.out.println("Page two value did change to " + value);
                    label.setText(Integer.toString(model.getValue()));
                }
            });

            setLayout(new GridBagLayout());
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.gridwidth = GridBagConstraints.REMAINDER;

            label = new JLabel(Integer.toString(model.getValue()));
            add(label, gbc);

            button = new JButton("Click me");
            button.addActionListener(e -> printTwo());
            add(button, gbc);
        }

        public void printTwo() {
            System.out.println("Page Two:" + model.getValue());
        }
    }
}

但是为什么有两种模型

停下来思考一下每个组件的职责。

PageOne 想要更新模型，为此，它还需要知道模型的值。该模型没有假设该模型的使用者“如何”执行此操作（因此我没有提供增量方法），它只是允许使用者设​​置它想要的值

PageTwo 只是想显示值（并在发生某些更改时收到通知），因此它不需要模型的可变版本。

这限制了消费者可以对模型执行的操作，而不是将功能暴露给不需要它的各方（并且可能会试图滥用它）

这是一个演示，您的需求可能会有所不同，但我有点守财奴当我设计这类东西时，我需要消费者向我证明他们需要功能，而不是“假设”他们“可能”需要什么功能