java对象间通信

还在学习Java。

Swing 又让我问了这个问题，但这确实是一个普遍的面向对象问题。如果我有一个主类（包含 main()），它会创建一个执行某些操作的新对象“A”，主类现在具有对该对象的引用，对象“B”如何访问该对象的属性？

我能想到的唯一方法是让主类创建一个新对象“B”，将对象“A”作为参数传递给构造函数，我认为这是可以的。但这不会使事件处理变得困难吗？

例如，也许这是一个糟糕的设计导致了问题。我有一个带有程序逻辑的大师班，它创建一个标准的 Swing 框架，带有一个菜单，菜单项具有动作侦听器。但动作监听器需要与外部对象交互。

所以一些代码（忽略细节）：

主类，包含程序逻辑以及保存和加载方法等：

public final class TheProgramme implements WindowListener }
    private static final TheProgramme TP = new TheProgramme();
    // Declare Class variables, instance variables etc.

    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShewGUI();
            }
        });
    }

    private static void createAndShewGUI() {
        TP.populateAndShew();
    }

    private void populateAndShew() {
        final StandardFrame sF = new StandardFrame("TheProgramme");
        theFrame = sF.getMainFrame();
        theFrame.addWindowListener(this);
        theFrame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
        theFrame.pack(); theFrame.setVisible(true);
    }
...
}

因此，我们创建了一个标准框架对象，它创建了一个菜单、空面板和状态栏，但在菜单项上具有事件侦听器：

public class StandardFrame {
    // Declare instance variables that must be visible to the ActionListener inner class

    public StandardFrame(String theTitle) {
        mainFrame = new JFrame(theTitle);
        mainFrame.setJMenuBar(createMenuBar()); // ... the menu bar and ...
        mainFrame.setContentPane(createBlankPanel()); // ... a blank panel
        java.net.URL imageURL = TheProgramme.class.getResource("images/icon.png");
        if (imageURL != null) {
            ImageIcon icon = new ImageIcon(imageURL);
            mainFrame.setIconImage(icon.getImage());
        }
    }

    public JMenuBar createMenuBar() {
        ActionListener menuEvents = new MenuListener();
        JMenuBar aMenuBar = new JMenuBar();
        JMenu fileMenu = new JMenu("File"); fileMenu.setMnemonic(KeyEvent.VK_F);
        ...
        aMenuBar.add(fileMenu);
        ...
        JMenuItem newItem = new JMenuItem("New", KeyEvent.VK_N); newItem.addActionListener(menuEvents);
        newItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, ActionEvent.CTRL_MASK));
        ...
        fileMenu.add(newItem);
        ...
        return aMenuBar;
    }
}

class MenuListener implements ActionListener {

    public void actionPerformed(ActionEvent ae) {
        String actionCommand = ae.getActionCommand();
        switch (actionCommand) {
            case "New":
                // !!! here we need to call a method in an object to create a new document object !!!
                break;
             case "Reformat":
                // !!! here we need to call a method in the object created above
         }
     }
}

第一个问题是菜单项上的动作监听器调用一个方法来创建对象，但它不是对静态方法的调用。 第二个问题是它需要能够稍后由于另一个菜单选择而调用该新对象中的方法。

执行此操作的经典方法是模型-视图-控制器 http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller就是在运行时将对象绑定在一起。控制器（您的操作侦听器）采用参数来指示要操作的视图和模型。

正如 Aqua 提到的，这种参数的使用也称为“依赖注入”。

   public static void main( String[] args )
   {
      Model model = new Model();
      View view = new View();
      ActionListener listener = new MyActionListener( model, view );
      view.addActionListener( listener );
   }

   private static class MyActionListener implements ActionListener
   {
      private Model model;
      private View view;

      public MyActionListener( Model model, View view )
      {
         this.model = model;
         this.view = view;
      }
   }

在 Java 中，您可以作一点欺骗，因为 ActionEvent 有一个指向事件源的指针（通常是生成事件的视图/JComponent）。

private static class MyActionListener implements ActionListener
{
  private Model model;

  public MyActionListener( Model model )
  {
     this.model = model;
  }

  @Override
  public void actionPerformed( ActionEvent e )
  {
     JComponent source = (JComponent) e.getSource();
     // source == "view"...
  }
}

要设置新文档，您可以创建一个“文档持有者”类。 “新建”菜单项将新文档放入 Holder 类中。所有其他菜单项从持有者类“获取”文档。这是一个相当严格的 OO 范例，它不使用静态方法或字段，尽管它有点乏味。

Set up:

   public static void main( String[] args )
   {
      ModelDocumentHolder model = new ModelDocumentHolder();
      View view = new View();
      ActionListener listener = new NewDocument( model );
      view.addActionListener( listener );
      View view2 = new View();
      view2.addActionListener( new RegularListener( model ) );
   }

新文档监听器：

   private static class NewDocument implements ActionListener
   {
      private ModelDocumentHolder model;

      public NewDocument( ModelDocumentHolder model )
      {
         this.model = model;
      }

      @Override
      public void actionPerformed( ActionEvent e )
      {
         model.setDoc( new Document() );
      }
   }

大多数其他菜单项：

   private static class RegularListener implements ActionListener
   {
      private ModelDocumentHolder model;

      public RegularListener( ModelDocumentHolder model )
      {
         this.model = model;
      }

      @Override
      public void actionPerformed( ActionEvent e )
      {
         JComponent source = (JComponent) e.getSource();
         Document doc = model.getDoc();
         // do stuff...
      }
   }

持有者类别：

   private static class ModelDocumentHolder
   {
      private Document doc;

      public Document getDoc()
      {
         return doc;
      }

      public void setDoc( Document doc )
      {
         this.doc = doc;
      }

   }