Question

假设我正在构建Java Swing GUI，并且我有一个包含面板的框架，其中包含另一个面板，其中包含一个按钮。（假设这些面板是可重用的，所以我把它们变成了单独的类。）

Frame → FirstPanel → SecondPanel → Button

实际上，孩子们的行可能会更复杂，但我只是想让这个例子保持简单。

如果我希望按钮控制其中一个父组件（例如，调整框架大小），那么在两个GUI类之间实现功能的最佳方法是什么？这两个类不一定直接在另一个内部？

我不喜欢将getParent()方法串联在一起的想法，或者将Frame的实例一直传递给它的子节点，以便可以从SecondPanel访问它。基本上，我不想以这种或那种方式将我的课程连接在一起。

这是一个按钮应该更新模型而不是直接更新父组件的实例吗？然后父母会收到模型更改的通知并相应地自行更新？

我已经汇总了一个应该编译并运行的小例子来说明我的问题。这是JPanel中的两个JButton，另一个JPanel中的JFrame。按钮控制JFrame的大小。

import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class MVCExample
{
    public static void main(String[] args)
    {
        Model model = new Model();

        Controller ctrl = new Controller();
        ctrl.registerModel(model);

        View view = new View(ctrl);
        view.setVisible(true);

        model.init();
    }

    /**
     * Model class
     */
    static class Model
    {
        private ArrayList<PropertyChangeListener> listeners =
                new ArrayList<PropertyChangeListener>();

        private Dimension windowSize;

        public Dimension getWindowSize(){ return windowSize; }

        public void setWindowSize(Dimension windowSize)
        {
            if(!windowSize.equals(getWindowSize()))
            {
                firePropertyChangeEvent(getWindowSize(), windowSize);
                this.windowSize = windowSize;
            }
        }

        public void init()
        {
            setWindowSize(new Dimension(400, 400));
        }

        public void addListener(PropertyChangeListener listener)
        {
            listeners.add(listener);
        }

        public void firePropertyChangeEvent(Object oldValue, Object newValue)
        {
            for(PropertyChangeListener listener : listeners)
            {
                listener.propertyChange(new PropertyChangeEvent(
                        this, null, oldValue, newValue));
            }
        }
    }

    /**
     * Controller class
     */
    static class Controller  implements PropertyChangeListener
    {
        private Model model;
        private View view;

        public void registerModel(Model model)
        {
            this.model = model;
            model.addListener(this);
        }

        public void registerView(View view)
        {
            this.view = view;
        }

        // Called from view
        public void updateWindowSize(Dimension windowSize)
        {
            model.setWindowSize(windowSize);
        }

        // Called from model
        public void propertyChange(PropertyChangeEvent pce)
        {
            view.processEvent(pce);
        }
    }

    /**
     * View classes
     */
    static class View extends JFrame
    {
        public View(Controller ctrl)
        {
            super("JFrame");

            ctrl.registerView(this);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            getContentPane().add(new FirstPanel(ctrl));
            pack();
        }

        public void processEvent(PropertyChangeEvent pce)
        {
            setPreferredSize((Dimension)pce.getNewValue());
            pack();
        }
    }

    static class FirstPanel extends JPanel
    {
        public FirstPanel(Controller ctrl)
        {
            setBorder(BorderFactory.createTitledBorder(
                    BorderFactory.createLineBorder(
                    Color.RED, 2), "First Panel"));

            add(new SecondPanel(ctrl));
        }
    }

    static class SecondPanel extends JPanel
    {
        private Controller controller;
        private JButton smallButton = new JButton("400x400");
        private JButton largeButton = new JButton("800x800");

        public SecondPanel(Controller ctrl)
        {
            this.controller = ctrl;
            setBorder(BorderFactory.createTitledBorder(
                    BorderFactory.createLineBorder(
                    Color.BLUE, 2), "Second Panel"));

            add(smallButton);
            add(largeButton);

            smallButton.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent ae)
                {
                    controller.updateWindowSize(new Dimension(400, 400));
                }
            });

            largeButton.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent ae)
                {
                    controller.updateWindowSize(new Dimension(800, 800));
                }
            });
        }
    }
}

我不喜欢的是，控制器需要存在于JFrame中，以便框架可以注册自己以接收事件。但是控制器必须一直传递到SecondPanel（第112,131和143行），以便面板可以与模型通信。

我觉得这里有一些效率低下的东西（而且这些课程的联系太紧了）。如果我的问题不明确，请告诉我。

Answer 1

在Swing中，控制器和视图通常属于UI委托，模型是独立的。视图可以构造一个复杂的组件层次结构来表示模型，并且控制器会根据需要监听它们。该组件仅用于将两个部分连接在一起的各种簿记。

因此，例如，在组合框中，JCombobox是您设置UI和模型的地方。 ComboboxUI组装组成组合框的组件 - 渲染器或编辑器和按钮，以及弹出窗口和列表 - 并提供布局和可能的自定义渲染。这是View逻辑。它还会侦听所有这些组件并根据需要修改模型。这是控制器级别。对模型的更改通过事件向组件冒泡。

因此，在您的情况下，视图代码无法构建整个组件层次结构。我希望模型为更改自己的属性的按钮提供Actions，然后让视图侦听该属性更改并调整窗口大小：

class View implements PropertyChangeListener {
    JFrame frame;

    View(Model model) {
        model.addPropertyChangeListener(this);

        frame = new JFrame();

        List<Action> actions = model.getActions();

        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(1, actions.size()));

        for(Action action : actions) {
            panel.add(new JButton(action));
        }

        frame.getContentPane().add(panel);
        frame.pack();
        frame.setVisible(true);
    }

    public void propertyChange(PropertyChangeEvent evt) {
        frame.setSize((Dimension)evt.getNewValue())
    }
}

class Model {
    List<Action> actions = new ArrayList<Action>();
    Dimension dimension;

    Model() {
        actions.add(new DimensionAction(400, 400));
        actions.add(new DimensionAction(800, 800));
    }

    List<Action> getActions() {
        return Collections.unmodifiableList(actions);
    }

    void setDimension(Dimension newDimension) {
        Dimension oldDimension = this.dimension;
        this.dimension = newDimension;

        firePropertyChange("dimension", oldDimension, newDimension);
    }

    ... Property change support ...

    class DimensionAction extends AbstractAction {
        Dimension dimension;

        DimensionAction(int width, int height) {
            super(width + "x" + height);
            this.dimension = new Dimension(width, height);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            Model.this.dimension = dimension;
        }
    }
}

Answer 2

如果您希望您的类保持分离，可以添加一个ViewFactory来处理所有部分的链接。这样的事情可能有用：

static interface ViewFactory {
    View makeView(Controller c);
}

static class DefaultViewFactory implements ViewFactory {
    public View makeView(Controller c) {
        Button b = new Button();
        b.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                c.updateWindowSize(new Dimension(800, 600));
        });
        Panel2 p2 = new Panel2();
        p2.add(b);
        Panel1 p1 = new Panel1();
        p1.add(p2);
        View v = new View();
        v.add(p1);
        return v;
    }
}

然后你有了将所有类链接在一个单独的地方的代码，它可以独立于你的控制器和你的View实现而变化。

HTH，

子GUI组件应如何访问其父项（使用MVC）？

2 个答案: