Am I understanding observers/observables correctly?

[Jon Swanson]

Here is my effort to implement a GUI that gets information from two panels and displays the information back to one of those panels and another output only panel. It's a lot simpler than what I need to implement eventually, but do I have the idea right? It seemed a little squirrelly to me to be both adding an object as an observer so that its view could be updated and passing the observer in as an argument so that I could access the data.

I'm also a little unsure about my setValue methods in the Observable. Different objects will set different subsets of the data. I 'cheated' in the example since the parameter types were different. Should I define some additional classes for the subsets of my data, which would allow me to more cleanly overload the setValue method? And then define yet another class that contains all this subsets that the notifyObservers() method returns or is it better not to pass an object with the updated data and have a bunch of methods that let each observer pull out what matters to them? And is there a simple way to indicate some subset of the data did not change, so some objects don't need to update?

/*
 * Test of communication between GUI objects
 *
 */

// Import all the classes that will be used
import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.SwingUtilities;
import javax.swing.BorderFactory;
import  javax.swing.border.Border;

import javax.swing.JPanel;
import javax.swing.JFrame;

import java.util.Observer.*;
import java.util.Observable.*;

// Assemble the components of the dialog

public class GuiTest extends JFrame {

// Parameters for constructing the main GUI
   private static final int MAIN_GUI_WIDTH  = 600;
   private static final int MAIN_GUI_HEIGHT = 450;

   private static final String NAME_MAIN   = "GUI Test";
   private static final String NAME_FRAME1 = "Input/Output";
   private static final String NAME_FRAME2 = "Input";
   private static final String NAME_FRAME3 = "Output";

   private JPanel inputOutputPanel;
   private JPanel inputPanel;
   private JPanel outputPanel;

   public GuiTest() {

      JFrame mainFrame = new JFrame( NAME_MAIN );
      mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      inputOutputPanel = new JPanel( new FlowLayout() );
      inputOutputPanel.setBorder( BorderFactory.createTitledBorder(
			      	       NAME_FRAME1 ) );

      inputPanel       = new JPanel( new FlowLayout() );
      inputPanel.setBorder( BorderFactory.createTitledBorder(
			      	       NAME_FRAME2 ) );

      outputPanel      = new JPanel( new FlowLayout() );
      outputPanel.setBorder( BorderFactory.createTitledBorder(
			      	       NAME_FRAME3 ) );
//
// Create my observable
//
      FakeObserver fakeObserver = new FakeObserver();
//
// Populate the panels
//
      FakeTable ftab = new FakeTable(fakeObserver);
      inputOutputPanel.add(ftab);

      FakeSpinner fs = new FakeSpinner(fakeObserver);
      inputPanel.add(fs);

      FakeText ftxt  = new FakeText();
      outputPanel.add(ftxt);

      fakeObserver.addObserver(ftab);
      fakeObserver.addObserver(ftxt);

// OK, now put things into the main container
      Container mainContent = mainFrame.getContentPane();
      mainContent.setLayout(new GridLayout(3,1));
      mainContent.add(inputOutputPanel);
      mainContent.add(inputPanel);
      mainContent.add(outputPanel);

      mainFrame.setSize(MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT);
      mainFrame.setVisible(true);
   }

   public static void main(String[] args) {
      GuiTest guiTest = new GuiTest();
   }

}

import java.util.*;
import java.util.Observable.*;

class FakeObserver extends Observable
{
   static final int SCALE = 0;
   static final int TABLE = 1;

   private ArrayList  observerData = new ArrayList();
   private Double[][] tableData = new Double[2][2];
   private Double     scale = 1.0;

   FakeObserver() 
   {
      observerData.add(scale);
      observerData.add(tableData);
   }

   public void setValue( int row, double value )
   {
      tableData[row][0] = value;
      tableData[row][1] = value * scale;
      observerData.clear();
      observerData.add(scale);
      observerData.add(tableData);
      setChanged();
      notifyObservers(observerData);
   }

   public void setValue( double scale )
   {
      this.scale = scale;
      if (tableData[0][0] != null)
         tableData[0][1] = tableData[0][0] * scale;
      if (tableData[1][0] != null)
         tableData[1][1] = tableData[1][0] * scale;
      observerData.clear();
      observerData.add(scale);
      observerData.add(tableData);
      setChanged();
      notifyObservers(observerData);
   }

   public ArrayList getValue()
   {
      return observerData;
   }
}

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.util.Observer;
import java.util.Observable;

class FakeTable extends JPanel implements Observer
{
   JLabel labelOne;
   JLabel labelTwo;
   JTextField textOneIn;
   JTextField textTwoIn;
   JTextField textOneOut;
   JTextField textTwoOut;

   FakeObserver ov;

   FakeTable(FakeObserver ov)
   {
      this.ov  = ov;

      setLayout( new GridLayout(2, 3) );

      labelOne = new JLabel( "Enter Number One" );
      labelTwo = new JLabel( "Enter Number Two" );

      textOneIn  = new JTextField(8);
      textTwoIn  = new JTextField(8);
      textOneOut = new JTextField(8);
      textTwoOut = new JTextField(8);

      textOneIn.addActionListener(new textActionListener());
      textTwoIn.addActionListener(new textActionListener());

      add(labelOne);
      add(textOneIn);
      add(textOneOut);
      add(labelTwo);
      add(textTwoIn);
      add(textTwoOut);

      textOneOut.setEditable(false);
      textTwoOut.setEditable(false);
   }

   public void update(Observable obs, Object obj)
   {
      Double[][] tableData;
      Double     scale;

      ArrayList myObj = (ArrayList) obj;

      scale     = (Double)     myObj.get(0);
      tableData = (Double[][]) myObj.get(1);

      if (tableData[0][1] != null)
         textOneOut.setText(String.format("%.2f", tableData[0][1]));
      if (tableData[1][1] != null)
         textTwoOut.setText(String.format("%.2f", tableData[1][1]));
   }
   
   private class textActionListener implements ActionListener
   {
      public void actionPerformed(ActionEvent e)
      {
         double value;
         if (e.getSource() == textOneIn)
         {
            value = Double.parseDouble(textOneIn.getText());
            ov.setValue(0, value);
	    return;
         }
         if (e.getSource() == textTwoIn)
         {
            value = Double.parseDouble(textTwoIn.getText());
            ov.setValue(1, value);
	    return;
         }
      }
   }
}

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

import java.util.Observer;
import java.util.Observable;

class FakeSpinner extends JPanel implements ChangeListener
{
   static final double DEFAULTVALUE = 1;
   static final double MINVALUE =  1;
   static final double MAXVALUE = 10;
   static final double STEP     =  1;

   FakeObserver ov;
   JLabel       labelOne;
   JSpinner     spinnerOne;
   SpinnerModel model;

   FakeSpinner(FakeObserver ov)
   {
      this.ov = ov;

      setLayout( new GridLayout(1, 2) );

      model = new SpinnerNumberModel(DEFAULTVALUE, MINVALUE, MAXVALUE, STEP);

      labelOne = new JLabel( "Multiplier" );

      spinnerOne = new JSpinner(model);
      spinnerOne.addChangeListener(this);

      add(labelOne);
      add(spinnerOne);
   }

   public void stateChanged(ChangeEvent e)
   {
      double  value;
      
      value = (Double) model.getValue();
      ov.setValue( value );
   }
}

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.util.Observer;
import java.util.Observable;

class FakeText extends JPanel implements Observer
{
   JLabel    labelOne;
   JTextArea textOne;

   FakeText()
   {
      setLayout( new GridLayout(2, 1) );

      labelOne = new JLabel( "Results" );

      textOne  = new JTextArea(3,40);
      textOne.setEditable(false);

      add(labelOne);
      add(textOne);
   }

   public void update(Observable obs, Object obj)
   {
      Double[][] tableData;
      Double     scale;
      String     myText = "";

      ArrayList myObj = (ArrayList) obj;

      scale     = (Double)     myObj.get(0);
      tableData = (Double[][]) myObj.get(1);

      for (int i=0; i < 2; i++)
         if (tableData[i][0] != null && tableData[i][1] != null)
            myText += String.format("%.2f times %.2f equals %.2f\n",
                                      tableData[i][0], scale, tableData[i][1]);

      textOne.setText(myText);
   }
}