首先，你要解耦你的代码。在你的“输入”UI和“输出”UI之间不应该有直接的关系。这将使代码的重用和维护变得更加容易。
为此，您应该使用“模型-视图-控制器”概念。也就是说，模型提供数据，视图以某种有意义的方式呈现数据。
添加“观察者模式”，对象可以监视模型，并在某些状态发生变化时采取行动。
例如...

public interface Model {
    public interface Observer {
        public void modelDidChange(Model model);
    }
    
    public void addObserver(Observer observer);
    public void removeObserver(Observer observer);
    public LocalDateTime getDate();
}

这是一个非常简单的演示，但是，Model是LocalDateTime值的容器。它还通过使用Model.Observer提供了“可观察性”，因此当模型发生变化时，感兴趣的各方可以得到通知。
在某些时候，我们可能想要改变模型的值，在这种情况下，我们可以使用一个专门的模型。

public interface MutableModel extends Model {
    public void setDate(LocalDateTime date);
}

这基本上描述了一个模型，其值可以改变。
为什么这很重要？这隔离了责任，不是模型的所有消费者都想要或应该被允许修改模型的状态，这里我们支持“关注点/责任分离”原则。
我个人也喜欢interface s，因为它们提供了合约的描述，而没有公开实现，这使得它们非常灵活。
接下来，我们需要模型的实现。你怎么做可能并不重要，但我从一个AbstractModel开始。

public abstract class AbstractModel implements Model {
    private List<Observer> observers = new ArrayList<>();

    protected List<Observer> getObservers() {
        return observers;
    }

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

    @Override
    public void removeObserver(Observer observer) {
        getObservers().remove(observer);
    }
    
    protected void fireModelDidChange() {
        for (Observer observer : getObservers()) {
            observer.modelDidChange(this);
        }
    }
}

这实现了所有其他模型都需要的核心“锅炉板”功能。注意，我没有实现getDate方法，这是故意的，因为如何管理这个值应该取决于实际的实现。
接下来，我实现了一个“可变”模型的概念。

public class DefaultMutableModel extends AbstractModel implements MutableModel {
    private LocalDateTime date;

    @Override
    public LocalDateTime getDate() {
        return date;
    }
    
    public void setDate(LocalDateTime date) {
        this.date = date;
        fireModelDidChange();
    }
}

我认为这是不言自明的。
这一切都很好，但我们实际上如何使用它？
好吧，基本上，我们可以创建模型的示例，并将其传递给需要它的各种对象，这是一个“依赖注入”的概念，例如......

ActionPane

public class ActionPane extends JPanel {
    private MutableModel model;

    public ActionPane(MutableModel model) {
        this.model = model;
        setLayout(new GridBagLayout());
        setBorder(new EmptyBorder(32, 32, 32, 32));
        
        JButton btn = new JButton("Tick");
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                getModel().setDate(LocalDateTime.now());
            }
        });
        add(btn);
    }

    public MutableModel getModel() {
        return model;
    }
}

OutputPane

public class OutputPane extends JPanel {
    private Model model;
    private JLabel label;

    public OutputPane(Model model) {
        this.model = model;
        setLayout(new GridBagLayout());
        setBorder(new EmptyBorder(32, 32, 32, 32));
        
        add(getLabel());
        
        model.addObserver(new Model.Observer() {
            @Override
            public void modelDidChange(Model model) {
                label.setText(DateTimeFormatter.ISO_LOCAL_TIME.format(model.getDate()));
            }
        });
    }
    
    protected JLabel getLabel() {
        if (label != null) {
            return label;
        }
        label = new JLabel("------------");
        return label;
    }

    public Model getModel() {
        return model;
    }
}

这两个面板是分开的，彼此不知道，但通过模型，他们可以沟通。
现在，我们简单地创建一个模型和UI.

MutableModel model = new DefaultMutableModel();

add(new ActionPane(model));
add(new OutputPane(model));

就是这样当模型的状态改变时，UI将被更新。

可运行示例.

import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
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.border.EmptyBorder;

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();
                frame.add(new MainPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class MainPane extends JPanel {
        public MainPane() {
            MutableModel model = new DefaultMutableModel();
            setLayout(new GridLayout(1, 2));

            add(new ActionPane(model));
            add(new OutputPane(model));
        }
    }

    public interface Model {
        public interface Observer {
            public void modelDidChange(Model model);
        }

        public void addObserver(Observer observer);

        public void removeObserver(Observer observer);

        public LocalDateTime getDate();
    }

    public interface MutableModel extends Model {
        public void setDate(LocalDateTime date);
    }

    public abstract class AbstractModel implements Model {
        private List<Observer> observers = new ArrayList<>();

        protected List<Observer> getObservers() {
            return observers;
        }

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

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

        protected void fireModelDidChange() {
            for (Observer observer : getObservers()) {
                observer.modelDidChange(this);
            }
        }
    }

    public class DefaultMutableModel extends AbstractModel implements MutableModel {
        private LocalDateTime date;

        @Override
        public LocalDateTime getDate() {
            return date;
        }

        public void setDate(LocalDateTime date) {
            this.date = date;
            fireModelDidChange();
        }
    }

    public class ActionPane extends JPanel {
        private MutableModel model;

        public ActionPane(MutableModel model) {
            this.model = model;
            setLayout(new GridBagLayout());
            setBorder(new EmptyBorder(32, 32, 32, 32));

            JButton btn = new JButton("Tick");
            btn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    getModel().setDate(LocalDateTime.now());
                }
            });
            add(btn);
        }

        public MutableModel getModel() {
            return model;
        }
    }

    public class OutputPane extends JPanel {
        private Model model;
        private JLabel label;

        public OutputPane(Model model) {
            this.model = model;
            setLayout(new GridBagLayout());
            setBorder(new EmptyBorder(32, 32, 32, 32));

            add(getLabel());

            model.addObserver(new Model.Observer() {
                @Override
                public void modelDidChange(Model model) {
                    label.setText(DateTimeFormatter.ISO_LOCAL_TIME.format(model.getDate()));
                }
            });
        }

        protected JLabel getLabel() {
            if (label != null) {
                return label;
            }
            label = new JLabel("------------");
            return label;
        }

        public Model getModel() {
            return model;
        }
    }
}

你应该注意到，我没有在哪里需要调用revalidate，invalidate或repaint来更新标签。除了将初始值设置为一个“合理的”长值之外，标签（通常）是自我更新的。
我已经提到了很多“概念”和“术语”，我强烈建议你花时间进一步研究它们，因为它们对你解决未来的问题是无价的。