Help Client Server implementaion

[jon ladd]

I know this is alot but I am stuck, the code below is what I have come up with so far from are instructor example, any Ideas, or correction would be greatly appreceiated.
Requirements:
In a single source file named App.java, define a public class named App that can be run as either a multithreaded Windows server or as a Windows client to process a telephone directory. Two other non-public classes must also be defined. One, named Person, will encapsulate the data and processing of a person. The other, named ServerThread, will define the processing of a server thread for each client.
The server (via its threads) will handle client requests to add, find, and delete Person objects maintained within a HashMap using the person's name as the key. It must store the HashMap to disk when it is shutdown and reload the HashMap from disk when it is restarted.
The client will provide a GUI front-end for adding, finding, and deleting Person objects.
Define a serializable Person class outside of the App class. It must only encapsulate name (String) and phone number (String). Code a single constructor to instantiate an object using values received for both instance variables. Provide simple "set" and "get" methods (setName(), getName(), etc.) to store and retrieve the value of each instance variable. Do NOT be concerned with editing the values of the instance variables.
Define the App class for a Windows program that will immediately ask the user to specify the processing mode (client or server). The technique for determining the processing mode is up to you (Choice, Checkbox, Buttons, etc.). Based upon the mode, processing is as follows:
Server processing
Using a FileDialog, ask the user for the name and location of the telephone directory file. If the specified file has a length other than zero, read it as a HashMap. Otherwise, instantiate a new HashMap for the telephone directory.
Loop to accept client logins. When one occurs, construct a new ServerThread with references to its Socket and the HashMap. Then, call the thread's start() method to begin its processing.
When the Window is closed, destroy all threads and write the HashMap to disk.
ServerThread processing
During construction, establish an ObjectInputStream and an ObjectOutputStream for the socket.
The run() method must handle client requests to add a Person to, find a Person in, or delete a Person from the HashMap. Develop your own scheme for transaction codes but be sure to:
Send a String object to the client indicating the success or failure of an add or delete transaction. For example, "person added", "person already exists", "person deleted", or "person not found".
Send a Person object to the client for a find transaction. If the person was not found within the HashMap, send a Person object having null values for name and phone number. Otherwise, send the found Person object.
Synchronize code to prevent two threads from working with the HashMap at the same time.
Provide a destroy() method to kill the thread.
Client processing
Provide a GUI with text fields for entering and displaying the person's name and phone number. Use buttons to trigger Add, Find, and Delete operations, and a text field or text area for displaying messages. The Delete button should only be enabled after a Find operation has succeeded. The choice of layout, colors, and fonts are up to you.
When Add is selected, verify that all data is present. If it is, construct a Person object, send it to the server as part of an add transaction, and read and display the server's reply. If not all data is present, send nothing to the server but display an error message.
When Find is selected, verify that the person's name is present. If it is, send the person's name to the server as part of a find transaction, read and display the server's reply, and enable the Delete button if the transaction was successful (note that after a successful find transaction, the person's name and phone number should appear on the screen). If the person's name is missing, send nothing to the server but display an error message.
When Delete is selected, verify that the person's name is present. If it is, send the person's name to the server as part of a delete transaction, read and display the server's reply, and disable the Delete button. If the person's name is missing, send nothing to the server but display an error message.

 // Provide easy access to packaged code.
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;

public class App extends Frame {
  // Instance variable for the processing mode.
  private int mode;
  // This constructor displays a dialog box from which the user may select the
  // processing mode.
  public App() {
    mode = new OptionDialog(this, "Select mode", "Server", "Client").choice();
  }
  // This is the main method for the application. It instantiates an App object
  // and, based on the user's choice of processing mode, launches as either a
  // "server" or a "client".
  public static void main(String[] args) {
    App go = new App();
    switch (go.mode) {
      case 1:
        new Server().process();
        break;
      case 2:
        new Client().process();
        break;
      default:
        System.exit(0);
    }
  }
}
// This class defines a multi-threaded windows server for maintaining an
// inventory of items to be shipped or received. A HashMap of Item objects is
// loaded from disk at start-up, maintained during processing, and written to
// disk at shut-down. Receiving (re-stocking the inventory) is handled via an
// automatic receiving thread. Shipping requests are received from one or more
// clients with each having its own thread. Another thread monitors the current
// inventory value of items in stock.
class Server extends FrameWindow {
  // Instance variables for referencing a panel of components to display the
  // current inventory value and various status messages.
  private Panel statusPanel;
 // private TextField valueField;
  private TextArea messages;
  // Instance variable for knowing if the file is currently open.
  private boolean openForInput;
  // Instance variable for referencing for the file path.
  private String filePath;
  // Instance variable for referencing the input file.
  private ObjectInputStream istream;
  // Instance variable for referencing the Map of inventory items.
  private Map items;
  // Class variable for referencing a Vector of thread references. Each client
  // that is currently connected will have a reference.
  private static Vector clients;
  // This constructor instantiates the server window.
  public Server() {
    // Call the superclass constructor to set the window's title.
    super("Phone Book server");
    // Set the frame's background color and size.
    setBackground(Color.lightGray);
    setSize(400, 200);
    // Center the frame on the screen and make it non-resizable.
    FrameWindow.center(this);
    setResizable(false);
    // Instantiate a panel to hold the current inventory value and various
    // status messages.
    statusPanel = new Panel();
    statusPanel.setLayout(new FlowLayout());

    // Create a label and scrollable text area to display status messages and
    // add them to the panel. The text area may not be modified by the user.
    statusPanel.add(
      new Label("----------------------- Message log -----------------------"));
    messages = new TextArea("", 5, 50, TextArea.SCROLLBARS_VERTICAL_ONLY);
    messages.setEditable(false);
    statusPanel.add(messages);
    // Add the status panel to the applet window.
    add(statusPanel);
    // Make the frame visible.
    setVisible(true);
  }
  // This method defines server processing.
  public void process() {
    // Instantiate a Vector to hold thread references for clients.
    clients = new Vector();
    // Local variable used to assign the next thread number.
    int threadNo = 1;
    // Display a start-up message.
    setMessage("Preparing to open the item file...");
    // Sleep for 3 seconds so the user can see the start-up message.
    try {
      Thread.sleep(3000);
    }
    catch (InterruptedException err) {}
    // Open the item file.
    openFile();
    // If the file is open, continue to activate server processing.
    if (openForInput) {
     
      // "try" to display the server address, declare a server socket for client
      // access, then loop to handle socket connections.
      try {
        // Construct the server socket. Port numbers 0 - 1023 are reserved, so
        // port number 7000 is specified.
        ServerSocket mySocket = new ServerSocket(7000);
        // Loop to accept connections and start associated threads.
        while (true) {
          // Construct a socket when a client "hits" the server socket.
          Socket connection = mySocket.accept();
          // Construct a server thread to handle client transactions, add the
          // thread reference to the vector, and start the thread's processing.
          ServerThread next = buildThread(connection, threadNo);
          clients.add(next);
          next.start();
          // Increment the thread number.
          threadNo++;
        }
      }
      // Catch any errors and display the associated message.
      catch(IOException err) {
        setMessage(err.getMessage());
      }
    }
    // If the file isn't open, display an error message, delay for 3 seconds,
    // and shut-down.
    else {
      setMessage("Server can't be activated");
      try {
        Thread.sleep(3000);
      }
      catch (InterruptedException err) {}
      dispose();
      System.exit(0);
    }
  }
  // This method can be called to open the item file. If the file specified by
  // the user is new (has a length of 0 bytes), it is automatically formatted
  // to hold 3 Item objects.
  private void openFile() {
    // "try" to open the file for input.
    try {
      // Create and display a FileDialog object through which the user may
      // specify the path (directory and file name) of the item file.
      FileDialog fd = new FileDialog(this, "Select item file", FileDialog.LOAD);
      fd.setVisible(true);
      // The file path is "pieced" together from information entered in the
      // FileDialog. The separator is platform dependent and obtained from the
      // File class.
      filePath = fd.getDirectory() + File.separator + fd.getFile();
      // If the specified file is empty, format it with 3 Item objects.
      if (new File(filePath).length() == 0) {

        // Instantiate a Map to hold the Item objects.
        items = new HashMap();
      }
        else {
          // "try" to open the file, populate the Map, and write the Map to disk.
          try {
            
istream = new ObjectInputStream(new FileInputStream(filePath));
           
 // Open the file by instantiating a new ObjectOutputStream object from
            // a new FileOutputStream object based upon the file path.
            openForInput = true;
          
           // items needs to be changed to persons
            person = (HashMap) istream.readObject();
            setMessage("Item file is open with " + items.size() + " records");

            // This catch block will display an appropriate error message.
          }
            catch (Exception err) {
              setMessage(err.getMessage() + " while initializing inventory");
            }
          }
         
          // This catch is needed to satisfy the compiler. The exception may be
          // when reading the HashMap object from the disk file.
    }
          catch (ClassNotFoundException err) {}
          // If an input error occurs, display an error message.
          catch (IOException x) {
            setMessage("Error reading item file");
          }
        }
     
      // This method can be called to instantiate and start a thread for processing
      // shipping requests from a client.
      private ServerThread buildThread(Socket connection, int threadNo) {
        // Construct the thread by passing it a reference to this frame, the socket,
        // the thread number, and the item Map. The reference is returned to the
        // caller.
        return new ServerThread(this, connection, threadNo, items);
      }
      // This method is automatically called when the window is being shut-down. It
      // overrides the windowClosing() method of the super class in order to kill
      // all threads and update the item file.
      public void windowClosing(WindowEvent e) {
        // Loop through the Vector of all client threads and kill them.
        for (int i = 0; i < clients.size(); i++) {
          ServerThread temp = (ServerThread) clients.get(i);
          temp.killThread();
        }
        // If the receiving thread is active, kill it.
        if (receive != null) {
          receive.killThread();
        }
        // If the thread to monitor the current inventory value is active, kill it.
        if (value != null) {
          value.killThread();
        }
        // "try" to write the updated Map back to the disk file;
        try {
          // Construct a new ObjectOutputStream for the item file.
          ObjectOutputStream ostream =
              new ObjectOutputStream(new FileOutputStream(filePath));
          // Write the Map to disk and close the file.
          ostream.writeObject(items);
          ostream.close();
          // Display a success message.
          setMessage("Item file is closed. " + items.size() +
                     " records written");
        }
        // This catch block displays an appropriate error message.
        catch (IOException x) {
          setMessage("Error writing item file to disk");
        }
        // Sleep for 3 seconds so the user can see the closing messages.
        try {
          Thread.sleep(3000);
        }
        catch (InterruptedException err) {}
        // Release all resources used by the frame and terminate the JVM.
        dispose();
        System.exit(0);
      }
      // This method can be called to set the current inventory value. It uses
      // synchronization so that only one thread at a time can call the method.
      public synchronized void setValue(double newValue) {
        valueField.setText(Utility.moneyFormat(newValue));
      }
      // This method can be called to add a new message to the scrollable text area.
      // It uses synchronization so that only one thread at a time can call the
      // method.
      public synchronized void setMessage(String newMessage) {
        messages.append(newMessage + "\n");
      }
// This class defines the processing of a server thread associated with a single
// client. It communicates with the client to process the client's transactions.
      class ServerThread
          extends Thread {
        // Instance variable for knowing the current thread state.
        private boolean alive;
        // Instance variables for referencing the parent server and the Map of
        // inventory items.
        private Server theServer;
        private Map theItems;
        // Instance variables for holding the thread number and the transaction code.
        private int threadNumber;
        private int transCode;
        // Instance variables for referencing the socket connection, a reader for
        // reading a transaction from the client, and a writer for sending a reply to
        // the client.
        Socket connection;
        BufferedReader fromClient;
        PrintWriter toClient;
        // Instance variable to reference a StringTokenizer to be used in parsing
        // data received from the client.
        StringTokenizer dataAsString;
        // Public constants for transaction codes and resulting status codes.
        //public static final int GET_ITEMS_CODE = 1;
       public static final int ADD_CODE = 1;
       public static final int FIND_CODE = 2;  
       public static final int  DELETE_CODE = 3;
     
   public static final boolean ACCEPTED = true;
  public static final boolean REJECTED = false;

        // This constructor instantiates the thread. It receives as parameters a
        // reference to the parent server, a reference to the socket, the assigned
        // thread number, and a reference to the Map of inventory objects.
        public ServerThread(Server iTheServer, Socket mySocket,
                            int myThreadNumber,
                            Map iTheItems) {
          // Indicate that the thread is now alive.
          alive = true;
          // Save the parent reference, socket reference, thread number, and inventory
          // Map reference.
          theServer = iTheServer;
          connection = mySocket;
          threadNumber = myThreadNumber;
          theItems = iTheItems;
          // Display a message indicating that the thread is running.
          theServer.setMessage("Thread " + threadNumber + ": running");
          // "try" to create objects for reading and writing client data streams. The
          // PrintWriter will automatically flush the stream after data is sent.
          try {
            fromClient =
                new BufferedReader(new InputStreamReader(connection.
                getInputStream()));
            toClient = new PrintWriter(connection.getOutputStream(), true);
          }
          // If an error occurs, display the message associated with the error.
          catch (IOException err) {
            theServer.setMessage(err.getMessage());
          }
        }
        // This method defines thread processing.
        public void run() {
          
              // Process the transaction based upon the transaction code.
              switch (transCode) {
                // This case handles a transaction 
                case ADD_CODE: {}
                case FIND_CODE : {}
                case DELETE_CODE : { }
                  
// This class defines a frame with exit handling features so it can be properly
// closed. It subclasses Frame and implements a WindowListener interface in
// order to respond to window events. A static (class) method is also provided
// to permit any window to be centered on the screen.
      class FrameWindow
          extends Frame
          implements WindowListener {
        // This constructor accepts no parameters. It calls the superclass constructor
        // and registers a listener to be notified of window events.
        public FrameWindow() {
          super();
          addWindowListener(this);
        }
        // This constructor accepts a String for the frame's title and passes it
        // through to the superclass constructor. It then registers a listener to be
        // notified of window events.
        public FrameWindow(String title) {
          super(title);
          addWindowListener(this);
        }
        // This class method can be called to center any window on the screen. The
        // window is received as a parameter. If it is too large to fit, it is
        // downsized.
        public static void center(Window theWindow) {
          // Determine the screen size (its width and height) in pixels.
          Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
          int screenWidth = screenSize.width;
          int screenHeight = screenSize.height;
          // Determine the window size.
          Dimension frameSize = theWindow.getSize();
          // Calculate the x and y coordinates for top left corner of the window.
          int x = (screenWidth - frameSize.width) / 2;
          int y = (screenHeight - frameSize.height) / 2;
          // If the window is bigger than the screen, size the it to fit.
          if (x < 0) {
            x = 0;
            frameSize.width = screenWidth;
          }
          if (y < 0) {
            y = 0;
            frameSize.height = screenHeight;
          }
          // Move the window to its new location.
          theWindow.setLocation(x, y);
        }
        // Implement the abstract windowClosing() method of the WindowListener
        // interface.
        public void windowClosing(WindowEvent e) {
          // Release all resources used by the frame and terminate the JVM.
          dispose();
          System.exit(0);
        }
        // Implement other abstract methods of the WindowListener interface.
        public void windowOpened(WindowEvent e) {}
        public void windowActivated(WindowEvent e) {}
        public void windowIconified(WindowEvent e) {}
        public void windowDeiconified(WindowEvent e) {}
        public void windowDeactivated(WindowEvent e) {}
        public void windowClosed(WindowEvent e) {}
      }
// This class subclasses Thread to monitor the current inventory value for the
// server.
      class Value
          extends Thread {
        // Instance variable for knowing the current thread state.
        private boolean alive;
        // Instance variables for referencing the server and the Map of inventory
        // items.
        private Server theServer;
        private Map theItems;
        // This method constructs the thread object. It receives references to the
        // server and the Map of inventory items.
        public Value(Server iTheServer, Map iTheItems) {
          // Set the thread state and save the references.
          alive = true;
          theServer = iTheServer;
          theItems = iTheItems;
        }
        // This method overrides the default run() method of Thread. It defines
        // thread processing.
        public void run() {
        public void killThread() {
          alive = false;
        }
      }
 
// Ituses synchronization to lock the object and prevent simultaneous processing
// by multiple threads. The Serializable interface is implemented to permit
// object data to be read or written.

class Person implements Serializable{
// declares the instantce variables
  public string Name;
  public String phoneNumber;
 
  // method can be called for the part object
  public Part(String aName, String AphoneNumber) {
           SetName(aName);
   SetphoneNumber(AphoneNumber);
  }
 
  // This is called to get the value of the part number.
  public int getbName() {
    return Name;
  }
  // This is called to get the value of the description.
  public String getphNumber() {
    return phoneNumber;
  }
 
}
// This class defines a windows client for specifying how many of an item are
// to be shipped from the item inventory. It connects to and communicates with
// a multi-threaded server that assigns it a unique thread to process its
// transactions.
      class Client
          extends FrameWindow
          implements ActionListener, ItemListener {
        // Object references for networking.
        Socket connection;
        BufferedReader fromServer;
        PrintWriter toServer;
        // Object references for user interface components.
        TextField nameField;
        TextField phonebookField;
        private Button addButton;
        private Button findButton;
        private Button delButton;
        TextField message;
        // This constructor initializes the window.
        public Client() {
          // Call the superclass constructor and pass it the window title.
          super("Phonebook Client");
          // Specify the size (non-resizable), background color, and layout manager
          // for the frame.
          setSize(200, 200);
          setResizable(false);
          setBackground(Color.lightGray);
          setLayout(new FlowLayout());
          // Display a labeled list of item names from which the user may select the
          // item to be shipped. The list is initially empty. The item names will be
          // loaded from the server after the connection is established.
          
          // Display a labeled text box in which the user may enter how many of the
          // selected item are to be removed from the inventory.
          add(new Label("Name"));
          nameField = new TextField(15);
          add(nameField);
          // Display a labeled text box in which the user may enter information about
          // where or to whom the shipment is to be sent.
          add(new Label("Phone Number"));
          phonebookField = new TextField(10);
          add(phonebookField);
  addButton = new Button("Add");
          add(addButton);
          addButton.addActionListener(this);
    findButton = new Button("Find");
            add(findButton, con);
            findButton.addActionListener(this);   

     delButton = new Button("Delete");
          // delButton.setEnabled(false);
             add(delButton, con);
             delButton.addActionListener(this);       
// Construct a non-editable area in which messages may be displayed.
          message = new TextField(20);
          message.setEditable(false);
          add(message);
          // Make the frame visible.
          setVisible(true);
        }
        // This method defines client processing.
        public void process() {
          // "try" to connect to the server.
          try {
            // Connect to port 7000 on the current machine (for testing).
            connection = new Socket("localhost", 7000);
            // Create objects for reading and writing data streams. The PrintWriter
            // will automatically flush the stream after data is sent.
            fromServer =
                new BufferedReader(new InputStreamReader(connection.
                getInputStream()));
            toServer = new PrintWriter(connection.getOutputStream(), true);
            // Send a transaction to the server requesting a list of item names.
            toServer.println(ServerThread.GET_ITEMS_CODE);
            // Read and parse the server's response. Each token will be an item name
            // delimited by a comma.
            StringTokenizer dataAsString =
                new StringTokenizer(fromServer.readLine(), ",\n\r");
            // Strip-off the first item name (token).
            String itemName = dataAsString.nextToken();
            // Empty the contents of the item list. Then, loop to add each item name
            // to the item list while the token is not equal to "END".
            itemList.removeAll();
            while (! (itemName.equals("END"))) {
              itemList.addItem(itemName);
              itemName = dataAsString.nextToken();
            }
            // The first item in the list of item names is the default selection.
            itemList.select(0);
            // Indicate that the socket is now connected.
            message.setText("Connected to server");
          }
          // If an error occurs, display a message.
          catch (IOException err) {
            message.setText("Connection error");
          }
        }
        // This method implements the abstract method of the ActionListener interface.
        // In this client, it will be called only when the user has clicked the button
        // to send a shipping transaction to the server.
        public void actionPerformed(ActionEvent e) {
          // If the socket is connected, continue to construct the transaction.
          if (connection != null) {
            // Determine the item number based upon its position in the item list.
            int itemNo = itemList.getSelectedIndex() + 1;
            // Determine the quantity to be shipped based upon the value specified in
            // the "quantity to be shipped" text field. If the value isn't an integer,
            // 0 is assumed (to force an error).
            int quantity;
            try {
              quantity = Integer.parseInt(nameField.getText().trim());
            }
            catch (Exception err) {
              quantity = 0;
            }
            // If the quantity to ship is less than 1, display an error message.
            if (quantity < 1) {
              message.setText("Invalid Quantity");
              nameField.requestFocus();
            }
            // If the quantity to ship is valid, continue to build the shipping
            // transaction.
            else {
              // If no "ship to" information has been specified, display an error
              // message.
              if (phonebookField.getText() == null ||
                  phonebookField.getText().length() == 0) {
                message.setText("Invalid \"ship to\" information");
                phonebookField.requestFocus();
              }
              // Otherwise, all required data is present and the transaction can be
              // sent to the server for processing.
              else {
                // "try" to send the shipping request.
                try {
                  // Send the comma delimited data to the server.
                  toServer.println(ServerThread.SHIP_CODE + "," +
                                   itemNo + "," +
                                   quantity + "," +
                                   phonebookField.getText());
                  // Read and parse the server's response. Two tokens are received.
                  // The first indicates the success or failure of the shipping
                  // request. The second specifies how many of the shipped item are
                  // now in stock.
                  StringTokenizer dataAsString =
                      new StringTokenizer(fromServer.readLine(), ",\n\r");
                  boolean status =
                      new Boolean(dataAsString.nextToken()).booleanValue();
                  int newQuantity =
                      new Integer(dataAsString.nextToken()).intValue();
                  // If the server accepted the transaction, display a verification
                  // message.
                  if (status == ServerThread.ACCEPTED) {
                    message.setText("SHIPPED. " + newQuantity + " now in stock");
                  }
                  // Otherwise display an error message.
                  else {
                    message.setText("NOT SHIPPED. " + newQuantity + " in stock");
                  }
                  // Clear the "quantity to ship" field and give it focus.
                  nameField.setText("");
                  nameField.requestFocus();
                }
                // This catches a dropped connection and displays an error message.
                catch (SocketException err) {
                  message.setText("Socket error");
                }
                // This catches other errors and displays a message.
                catch (IOException err) {
                  message.setText("Transmission error");
                }
              }
            }
          }
        }
        // This method implements the abstract method of the ActionListener interface.
        // In this client, it means the user selected an item from the item list.
        public void itemStateChanged(ItemEvent e) {
          // Display a prompt message and give the "Name" field focus.
          message.setText("Enter Phone Number");
          nameField.requestFocus();
        }
      }
// This class subclasses Thread to simulate a warehouse receiving process to add
// items to an inventory.
      class Receive
          extends Thread {
        // Instance variable for knowing the current thread state.
        private boolean alive;
        // Instance variables for referencing the parent server and the Map of
        // inventory items.
        private Server theServer;
        private Map theItems;
        // This method constructs the Thread object. It receives references to the
        // parent server and the Map of inventory items.
        public Receive(Server iTheServer, Map iTheItems) {
          // Set the thread state and save the references.
          alive = true;
          theServer = iTheServer;
          theItems = iTheItems;
        }
        // This method overrides the default run() method of Thread. It defines
        // thread processing.
        public void run() {
          // Local variable for referencing the current inventory item.
          Item current;
          // Display a log message via the parent server.
          theServer.setMessage("Receiving: Started");
          // Loop as long as the thread state indicates the thread is alive.
          while (alive == true) {
            // Loop through the item Map looking for items that need to be
            // re-stocked.
            for (int i = 1; i <= theItems.size(); i++) {
              // Get the inventory item using its item number as the key. The cast is
              // needed to convert from a generic Object reference.
              current = (Item) theItems.get(new Integer(i).toString());
              // If the item's quantity in stock is less than or equal to its reorder
              // level, it needs to be re-stocked.
              if (alive == false)
                break;
            }
          }
          // Display a log message via the parent server and then exit.
        }
        // This method can be called to obtain a random sleep time of less than
        // 10 seconds.
        private int randomTime() {
          return (int) (10000 * Math.random());
        }
        // OLD UPDATE TO REORDER STUFF WENT HEREEEEEEEEEEEE!
        public void killThread() {
          alive = false;
        }
      }

// This class defines a frame for a modal, two-option dialog box that may be
// launched by another window. It subclasses Dialog and implements the
// WindowListener interface to handle window events. Anonymous inner interfaces
// are used to handle action events.
      class OptionDialog
          extends Dialog
          implements WindowListener {
        // Instance variable for holding the user's selection.
        private int selection;
        // This constructor constructs the modal message dialog box. As parameters, it
        // receives a reference to the parent frame, a String for the title, and two
        // String objects for the options to be displayed.
        public OptionDialog(Frame owner, String title, String opt1, String opt2) {
          // Pass the parent frame reference, title, and modal specifier through
          // to the superclass (Dialog) constructor.
          super(owner, title, true);
          // Set the layout manager for the dialog box.
          setLayout(new GridLayout(1, 2));
          // Construct a Button for each option to be displayed, add them to the
          // dialog box window, and define their processing via an anonymous inner
          // ActionListener.
          Button b1 = new Button(opt1);
          b1.setFont(new Font("SanSerif", Font.BOLD, 18));
          add(b1);
          b1.addActionListener(
              new ActionListener() {
            public void actionPerformed(ActionEvent e) {
              // Save selection and release dialog box resources.
              selection = 1;
              dispose();
            }
          }
          );
          Button b2 = new Button(opt2);
          b2.setFont(new Font("SanSerif", Font.BOLD, 18));
          add(b2);
          b2.addActionListener(
              new ActionListener() {
            public void actionPerformed(ActionEvent e) {
              // Save selection and release dialog box resources.
              selection = 2;
              dispose();
            }
          }
          );
          // Set the size of the dialog box window, center it on the screen,
          // register its listener, and make it visible.
          setSize(250, 100);
          FrameWindow.center(this);
          addWindowListener(this);
          show();
        }
        // This method can be called to obtain the selection.
        public int choice() {
          return selection;
        }
        // Implement the abstract windowClosing() method of the WindowListener
        // interface.
        public void windowClosing(WindowEvent e) {
          // Release dialog box resources.
          dispose();
        }
        // Implement other abstract methods of the WindowListener interface.
        public void windowOpened(WindowEvent e) {}
        public void windowActivated(WindowEvent e) {}
        public void windowIconified(WindowEvent e) {}
        public void windowDeiconified(WindowEvent e) {}
        public void windowDeactivated(WindowEvent e) {}
        public void windowClosed(WindowEvent e) {}
      }
    } 

[Ko Ko Naing]

I think if u break the problem into smaller questions and ask one by one, it'll be more comfortable for us to answer your questions...
For now, it'll take time for us to read such a bunch of coding lines and your explanation... Well, but I'll try my best to reply you with the complete program within two or three days... I do like such kind of programming challenge(Of course, not from you)

[jon ladd]

Thanks for taking the time to look at it

[Joe Ess]

Originally posted by Ko Ko Naing:
. . . I'll try my best to reply you with the complete program within two or three days...

That's a no-no, Ko Ko. Let's let Jon ask us specific questions so we can give him help without compromising his education.

[Ko Ko Naing]

Originally posted by Joe Ess:

That's a no-no, Ko Ko. Let's let Jon ask us specific questions so we can give him help without compromising his education.

Yeah, what Joe said is reasonable...
Jon, you should ask questions specific to the program... Actually I have already made your program compiled already... There were a lot, a lot of errors in the code... But it's not working properly yet... So just ask what you want to know... I'll be answering with the modified code in my hands...

[jon ladd]

Ok i am trying to get my add button working I had it compiling but now it just keep blowing up and I have no idea. I redid the code form the first example, for the most part.

  //Provides easy access to packaged code.
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;

public class App extends Frame {
  //Private instance variable for the processing mode.
  private int mode;
  //This constructor displays a dialog box from which the user may select the processing mode.
  public App() {
    mode = new OptionDialog(this, "Select Mode", "Server", "Client").choice();
  }
  //This is the main method for the application. It instantiates an App object and,
  //based on the user's choice of processing mode, launches as either a "server" or a "client".
  public static void main(String[] args) {
    App go = new App();
    switch (go.mode) {
      case 1:
        new Server().process();
        break;
      case 2:
        new Client().process();
        break;
      default:
        System.exit(0);
    }
  }
}
//This class defines a multi-threaded windows server for maintaining an
//inventory of items to be shipped or received. A HashMap of Item objects is
//loaded from disk at start-up, maintained during processing, and written to
//disk at shut-down. Receiving (re-stocking the inventory) is handled via an
//automatic receiving thread. Shipping requests are received from one or more
//clients with each having its own thread. Another thread monitors the current
//inventory value of items in stock.
class Server extends FrameWindow {
  //Instance variables for referencing a panel of components to display the
  //current inventory value and various status messages.
  private Panel statusPanel;
  //Private TextField valueField;
  private TextArea messages;
  //Instance variable for knowing if the file is currently open.
  private boolean openForInput;
  //Instance variable for referencing for the file path.
  private String filePath;
  //Instance variable for referencing the input file.
  private ObjectInputStream istream;
  //Instance variable for referencing the Map of inventory items.
  private Map items;
  //Class variable for referencing a Vector of thread references. Each client
  //that is currently connected will have a reference.
  private static Vector clients;
  //This constructor instantiates the server window.
  public Server() {
    //Call the superclass constructor to set the window's title.
    super("Server Side");
    //Set the frame's background color and size.
    setBackground(Color.lightGray);
    setSize(400, 140);
    //Center the frame on the screen and make it non-resizable.
    FrameWindow.center(this);
    setResizable(false);
    //Instantiate a panel to hold the current status messages.
    statusPanel = new Panel();
    statusPanel.setLayout(new FlowLayout());
    //Create a label and scrollable text area to display status messages and
    //add them to the panel. The text area may not be modified by the user.
    messages = new TextArea("", 5, 50, TextArea.SCROLLBARS_VERTICAL_ONLY);
    messages.setEditable(false);
    statusPanel.add(messages);
    //Add the status panel to the applet window.
    add(statusPanel);
    //Make the frame visible.
    setVisible(true);
  }
  //This method defines server processing.
  public void process() {
    //Instantiate a Vector to hold thread references for clients.
    clients = new Vector();
    //Local variable used to assign the next thread number.
    int threadNo = 1;
    //Display a start-up message.
    setMessage("Preparing to open the item file...");
    //Sleep for 3 seconds so the user can see the start-up message.
    try {
      Thread.sleep(3000);
    }
    catch (InterruptedException err) {}
    //Open the item file.
    openFile();
    //If the file is open, continue to activate server processing.
    if (openForInput) {
      //Start the automatic receiving thread and the thread to count the number
      //of records that have been created.
      startSupportThreads();
      //A "try" block to display the server address, declare a server socket for client
      //access, then loop to handle socket connections.
      try {
        //Display the server's internet address. The local host is used in this
        //application for testing purposes.
        setMessage("Server operational: " + InetAddress.getLocalHost());
        //Construct the server socket.  Port number 7000 is specified.
        ServerSocket mySocket = new ServerSocket(7000);
        //Loop to accept connections and start associated threads.
        while (true) {
          //Construct a socket when a client "hits" the server socket.
          Socket connection = mySocket.accept();
          //Construct a server thread to handle client transactions, add the
          //thread reference to the vector, and start the thread's processing.
          ServerThread next = buildThread(connection, threadNo);
          clients.add(next);
          next.start();
          //Increment the thread number.
          threadNo++;
        }
      }
      //Catch any errors and display the associated message.
      catch(IOException err) {
        setMessage(err.getMessage());
      }
    }
    //If the file isn't open, display an error message, delay for 3 seconds, and shut-down.
    else {
      setMessage("Server can't be activated");
      try {
        Thread.sleep(3000);
      }
      catch (InterruptedException err) {}
      dispose();
      System.exit(0);
    }
  }
  //This method can be called to open the item file. If the file specified by the user
  //is new (has a length of 0 bytes), it is automatically formatted to hold 3 Item objects.
  private void openFile() {
    //In a "try" bloack, open the file for input.
    try {
      //Create and display a FileDialog object through which the user may
      //specify the path (directory and file name) of the item file.
      FileDialog fd = new FileDialog(this, "Select item file", FileDialog.LOAD);
      fd.setVisible(true);
      //The file path is "pieced" together from information entered in the
      //FileDialog. The separator is platform dependent and obtained from the
      //File class.
      filePath = fd.getDirectory() + File.separator + fd.getFile();
      //If the specified file is empty, format it with 3 Item objects.
      if (new File(filePath).length() == 0) {
        //Object reference for an output stream.
        ObjectOutputStream ostream;
        //Instantiate a Map to hold the Item objects.
        items = new HashMap();
        //In a "try" block, open the file, populate the Map, and write the Map to disk.
        try {
          //Open the file by instantiating a new ObjectOutputStream object from
          //a new FileOutputStream object based upon the file path.
          ostream = new ObjectOutputStream(new FileOutputStream(filePath));
          //Write the Map to disk and close the file.
          ostream.writeObject(items);
          ostream.close();
        }
        //This catch block will display an appropriate error message.
        catch (Exception err) {
          setMessage(err.getMessage() + " while initializing inventory");
        }
      }
      //Open the file by instantiating a new ObjectInputStream object from a
      //new FileInputStream object.
      istream = new ObjectInputStream(new FileInputStream(filePath));
      //Indicate that file is open for output.
      openForInput = true;
      //Read the file as a generic object from disk and cast it to a Map.
      items = (HashMap) istream.readObject();
      //Display a message to indicate that the file is now open.
      setMessage("Item file is open with " + items.size() + " records");
    }
    //This catch is needed to satisfy the compiler. The exception may be
    //when reading the HashMap object from the disk file.
    catch(ClassNotFoundException err) {}
    //If an input error occurs, display an error message.
    catch(IOException x) {
      setMessage("Error reading item file");
    }
  }
  //This method can be called to instantiate and start the automatic receiving
  //thread and the thread to monitor the number of records that have been added.
  private void startSupportThreads() {
  }
  //This method can be called to instantiate and start a thread for processing
  //shipping requests from a client.
  private ServerThread buildThread(Socket connection, int threadNo) {
    //Construct the thread by passing it a reference to this frame, the socket,
    //the thread number, and the item Map. The reference is returned to the
    //caller.
    return new ServerThread(this, connection, threadNo, items);
  }
  //This method is automatically called when the window is being shut-down. It
  //overrides the windowClosing() method of the super class in order to kill
  //all threads and update the item file.
  public void windowClosing(WindowEvent e) {
    //Loop through the Vector of all client threads and kill them.
    for (int i = 0; i < clients.size(); i++) {
      ServerThread temp = (ServerThread) clients.get(i);
      temp.killThread();
    }
    //In a "try" block, write the updated Map back to the disk file;
    try {
      //Construct a new ObjectOutputStream for the item file.
      ObjectOutputStream ostream = new ObjectOutputStream(new FileOutputStream(filePath));
      //Write the Map to disk and close the file.
      ostream.writeObject(items);
      ostream.close();
      //Display a success message.
      setMessage("Item file is closed. " + items.size() + " records written");
    }
    //This catch block displays an appropriate error message.
    catch(IOException x) {
      setMessage("Error writing item file to disk");
    }
    //Sleep for 3 seconds so the user can see the closing messages.
    try {
      Thread.sleep(3000);
    }
    catch (InterruptedException err) {}
    //Release all resources used by the frame and terminate the JVM.
    dispose();
    System.exit(0);
  }
  //This method can be called to add a new message to the scrollable text area.
  //It uses synchronization so that only one thread at a time can call the method.
  public synchronized void setMessage(String newMessage) {
    messages.append(newMessage + "\n");
  }
}
//This class defines the processing of a server thread associated with a single client.
class ServerThread extends Thread {
  //Instance variable for knowing the current thread state.
  Map myObjects;
  private boolean alive;
  //Instance variables for referencing the parent server and the Map of
  //inventory items.
  private Server theServer;
  private Map theItems;
  //Instance variables for holding the thread number and the transaction code.
  private int threadNumber;
  private int transCode;
  //Instance variables for referencing the socket connection, a reader for
  //reading a transaction from the client, and a writer for sending a reply to
  //the client.
  Socket connection;
  ObjectInputStream fromClient;
  ObjectOutputStream toClient;
  //Instance variable to reference a StringTokenizer to be used in parsing
  //data received from the client.
  StringTokenizer dataAsString;
  //Public constants for transaction codes and resulting status codes.
  public static final int ADD = 1;
  public static final int DELETE = 2;
  public static final int FIND = 3;
  public static final boolean ACCEPTED = true;
  public static final boolean REJECTED = false;
  //This constructor instantiates the thread. It receives as parameters a
  //reference to the parent server, a reference to the socket, the assigned
  //thread number, and a reference to the Map of objects.
  public ServerThread(Server iTheServer, Socket mySocket, int myThreadNumber,
                      Map imyObjects) {
    //Indicate that the thread is now alive.
    alive = true;
    //Save the parent reference, socket reference, thread number, and objects
    //Map reference.
    theServer = iTheServer;
    connection = mySocket;
    threadNumber = myThreadNumber;
    theItems = imyObjects;
    //Display a message indicating that the thread is running.
    theServer.setMessage("Thread " + threadNumber + ": running");
    //In a "try" block, create objects for reading and writing data streams.
    //The PrintWriter will automatically flush the stream after data is sent.
    try {
      fromClient = new ObjectInputStream(connection.getInputStream());
      toClient = new ObjectOutputStream(connection.getOutputStream());
    }
    //If an error occurs, display the message associated with the error.
    catch (IOException err) {
      theServer.setMessage(err.getMessage());
    }
  }
  //This method defines thread processing.
  public void run() {
    //Loop while the thread is alive.
    while (alive == true) {
        switch (transCode) {
          //This case enters all the item's data into the file, item name, item
          //number, and item price.
          case ADD: {
          Person temp = (Person)fromClient.readObject();
tem.getPhoneNumber ();
tem.getPhoneNumber ();
          
item.add(tem.getItemName(),tem);
toClient.writeBoolean(true);
  //Local variable for referencing the current item.
            //Person current;
            //Break out of the switch.
            break;
          }
          //This case handles a request to delete item information from the file.
          case DELETE: {
            //Local variable for referencing the current item.
            Person current;
            //Parse the item number, the quantity to be shipped, and the "ship to" information.
            //int itemNo = new Integer(dataAsString.nextToken()).intValue();
            //int quantity = new Integer(dataAsString.nextToken()).intValue();
            //String shipTo = dataAsString.nextToken();
            //Get the inventory item using the item number as the key. The
            //cast is needed to convert from a generic object reference.
            //current = (Person) theItems.get(new Integer(itemNo).toString());
              //try {
              //theItems.put(new Integer(itemNo).toString(), current);
             // theServer.setMessage("Thread " + threadNumber + ": Shipped " +
                      //              quantity + " " + " to " + shipTo + ". " + " remain.");
             // }
             // catch (Exception err) {}
    //}
    //This case will find the items in the record.
    case FIND:{
    }
    
  }
}
}
  //Calling this method will set the thread state to indicate the thread is no longer alive.
  public void killThread() {
    alive = false;
  }
}
//This class defines a frame with exit handling features so it can be properly closed.
//It subclasses Frame and implements a WindowListener interface in order to respond to
//window events. A static (class) method is also provided to permit any window to be
//centered on the screen.
class FrameWindow extends Frame implements WindowListener {
  //This constructor accepts no parameters. It calls the superclass constructor
  //and registers a listener to be notified of window events.
  public FrameWindow() {
    super();
    addWindowListener(this);
  }
  //This constructor accepts a String for the frame's title and passes it through to
  //the superclass constructor. It then registers a listener to be notified of window events.
  public FrameWindow(String title) {
    super(title);
    addWindowListener(this);
  }
  //This class method can be called to center any window on the screen. The window
  //is received as a parameter. If it is too large to fit, it is downsized.
  public static void center(Window theWindow) {
    //Determine the screen size, its width and height, in pixels.
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    int screenWidth = screenSize.width;
    int screenHeight = screenSize.height;
    //Determine the window size.
    Dimension frameSize = theWindow.getSize();
    //Calculate the x and y coordinates for top left corner of the window.
    int x = (screenWidth - frameSize.width) / 2;
    int y = (screenHeight - frameSize.height) / 2;
    //If the window is bigger than the screen, size the it to fit.
    if (x < 0) {
      x = 0;
      frameSize.width = screenWidth;
    }
    if (y < 0) {
      y = 0;
      frameSize.height = screenHeight;
    }
    //Move the window to its new location.
    theWindow.setLocation(x, y);
  }
  //Implement the abstract windowClosing() method of the WindowListener interface.
  public void windowClosing(WindowEvent e) {
    //Release all resources used by the frame and terminate the JVM.
    dispose();
    System.exit(0);
  }
  //Implement other abstract methods of the WindowListener interface.
  public void windowOpened(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
}
//This class encapsulates the data and processing of an inventory item. It
//uses synchronization to lock the object and prevent simultaneous processing
//by multiple threads. The Serializable interface is implemented to permit
//object data to be read or written.
class Person implements Serializable {
  //Instance variables for item number, item name, and item price.
//itemNumber
  private int phoneNumber;
  private String itemName;
  //This constructor instantiates an item using values received as parameters.
  //It may throw an Exception if the data is invalid.
  public Person(int iPhoneNumber, String iItemName) throws Exception {
    //Try to pass each value to its corresponding set method.
    try {
      setPhoneNumber(iPhoneNumber);
      setItemName(iItemName);
     
    }
    //This catch block will be executed if any of the set methods threw an
    //Exception due to invalid data. It re-throws the error message.
    catch (Exception err) {
      throw new Exception(err.getMessage());
    }
  }
  //This method sets a new value for the item number. The item number must be positive.
  //If it isn't, an Exception is thrown. Due to synchronization, only one thread at a
  //time can call the method.
  public synchronized void setPhoneNumber(int newNumber) throws Exception {
    if (newNumber <= 0) {
      throw new Exception("Invalid phone number");
    }
    else {
      phoneNumber = newNumber;
    }
  }
  //This method sets a new value for the item name. It can not be blank or null.
  //If it is, an Exception is thrown. Due to synchronization, only one thread at a time
  //can call the method.
  public synchronized void setItemName(String newItemName)
    throws Exception {
    if (newItemName == null || newItemName.length() == 0) {
      throw new Exception("Invalid description");
    }
    else {
      itemName = newItemName;
    }
  }
 
  //This method can be called to get the item number. Synchronization is used so
  //that only one thread at a time can call the method.
  public synchronized int getPhoneNumber() {
    return phoneNumber;
  }
  //This method can be called to get the item name. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized String getItemName() {
    return itemName;
  }

}
//This class defines a windows client.  It connects to and communicates with
//a multi-threaded server that assigns it a unique thread to process its
//transactions.
class Client extends FrameWindow implements ActionListener, ItemListener {
  //Object references for networking.
  Socket connection;
  ObjectInputStream fromServer;
  ObjectOutputStream toServer;
  //Object reference for the current object.
  Person current;
  int transCode = 0;
  //Object references for the buttons in which the user presses in order to add, find,
  //delete or update item information, user interface components.
  Button add;
  Button find;
  Button delete;

  //Object references for the labels that label the textfields.
  Label itemname;
  Label phonenumber;
  //Object references for the textfields in which there is user input and also where
  //the results of a find will be displayed too.
  TextField phoneNumber;
  TextField itemName;
  TextArea message;

  //This constructor initializes the window.
 public Client() {
          // Call the superclass constructor and pass it the window title.
          super("Phonebook Client");
          // Specify the size (non-resizable), background color, and layout manager
          // for the frame.
          setSize(350, 350);
          setResizable(false);
          setBackground(Color.lightGray);
          setLayout(new FlowLayout());
          // Display a labeled list of item names from which the user may select the
          // item to be shipped. The list is initially empty. The item names will be
          // loaded from the server after the connection is established.
          
          // Display a labeled text box in which the user may enter how many of the
          // selected item are to be removed from the inventory.
            itemname = new Label("Enter Name");
           itemname.setAlignment(Label.CENTER);
            itemname.setFont(new Font("Serif", Font.BOLD, 16));
add(itemname);
 
          itemName = new TextField("           ");
          add(itemName);
          
          // Display a labeled text box in which the user may enter information about
          // where or to whom the shipment is to be sent.
 phonenumber = new Label("Enter  Phone Number");
    phonenumber.setAlignment(Label.CENTER);
    phonenumber.setFont(new Font("Serif", Font.BOLD, 16));
  add(phonenumber);
        phoneNumber = new TextField("           ");
        add(phoneNumber);
add = new Button("Add");
add.addActionListener(this);
add(add);
    
    find = new Button("Find");
    find.addActionListener(this);
    add(find);

    delete = new Button("Delete");
delete.addActionListener(this);
    add(delete);

        
// Construct a non-editable area in which messages may be displayed.
    message = new TextArea("",5,20,TextArea.SCROLLBARS_HORIZONTAL_ONLY);
    message.setFont(new Font("Serif", Font.ITALIC, 16));
    message.setEditable(false);
add(message);
          
// Make the frame visible.
          setVisible(true);
        }

  //This method defines client processing.
  public void process() {
    //A "try" block, to connect to the server.
    try {
      //Connect to port 7000 on the current machine.
      connection = new Socket("localhost", 7000);
      message.setText("Connected to server");
      //Create objects for reading and writing data streams. The PrintWriter will
      //automatically flush the stream after data is sent.
      fromServer = new ObjectInputStream(connection.getInputStream());
      toServer = new ObjectOutputStream(connection.getOutputStream());
    }
    //If an error occurs, display a message.
    catch (IOException err) {
      message.setText("Connection error");
    }
  }
  //This method implements the abstract method of the ActionListener interface.  In
  //this client, it will be called only when the user has clicks the add button.
  public void actionPerformed(ActionEvent e) {
  if (e.getSource().equals(add)) {
      try{
      if ((itemName.getText().trim().equals("")) | (phoneNumber.getText().trim().equals("")))
        {
          message.setText("Must enter all fields");
        }
     else {
            itemName.setText("");
            phoneNumber.setText("");
            System.out.println("saved");
            transCode = 1;
//inset trans code
Person tem = new Person (itemName.getText(),phoneNumber.getText)
toServer.writeInt(1);
toServer.writeObject(tem);
boolean reply = fromServer.read Boolean();
if (reply == true)
else {}

          }
          }
     catch(Exception err){
      message.setText(err.getMessage());
    }
    //If the socket is connected, continue to construct the transaction.
    if (connection != null) {
        }
      }
    }
  //This method implements the abstract method of the ActionListener interface.
  public void itemStateChanged(ItemEvent e) {
  //Display a prompt message and give the "quantity to ship" field focus.
  message.setText("Enter quantity and \"ship to\"");
}
}
//This class defines a frame for a modal, two-option dialog box that may be
//launched by another window. It subclasses Dialog and implements the
//WindowListener interface to handle window events. Anonymous inner interfaces
//are used to handle action events.
class OptionDialog extends Dialog implements WindowListener {
  //Instance variable for holding the user's selection.
  private int selection;
  //This constructor constructs the modal message dialog box. As parameters, it
  //receives a reference to the parent frame, a String for the title, and two
  //String objects for the options to be displayed.
  public OptionDialog(Frame owner, String title, String opt1, String opt2) {
    //Pass the parent frame reference, title, and modal specifier through to the
    //superclass (Dialog) constructor.
    super(owner, title, true);
    //Set the layout manager for the dialog box.
    setLayout(new GridLayout(1,2));
    //Construct a Button for each option to be displayed, add them to the dialog box
    //window, and define their processing via an anonymous inner ActionListener.
    Button b1 = new Button(opt1);
    b1.setFont(new Font("Serif", Font.BOLD, 18));
    add(b1);
    b1.addActionListener(
      new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          //Save selection and release dialog box resources.
          selection = 1;
          dispose();
        }
      }
    );
    Button b2 = new Button(opt2);
    b2.setFont(new Font("Serif", Font.BOLD, 18));
    add(b2);
    b2.addActionListener(
      new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          //Save selection and release dialog box resources.
          selection = 2;
          dispose();
        }
      }
    );
    //Set the size of the dialog box window, center it on the screen, register its
    //listener, and make it visible.
    setSize(250, 100);
    FrameWindow.center(this);
    addWindowListener(this);
    show();
  }
  //This method can be called to obtain the selection.
  public int choice() {
    return selection;
  }
  //Implement the abstract windowClosing() method of the WindowListener interface.
  public void windowClosing(WindowEvent e) {
    //Release dialog box resources.
    dispose();
  }
  //Implement other abstract methods of the WindowListener interface.
  public void windowOpened(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
}
//This class defines the transcode which is serializable.
class Transcode implements Serializable {
//Instance variables for the transcode number, the itme object, and the status of
//the object which is a boolean.
private int transcode;
Person object;
private boolean status;
//This constructor instantiates the transcode. It receives as parameters a reference
//to the transcode, a reference to the object, and the status of the transcode.
public Transcode ( int itranscode, Person iobject, boolean istatus)throws Exception {
//A "try" block to set the transcode, object, and status.
  try {
      setTranscode(itranscode);
      setObject(iobject);
      setStatus(istatus);
    }
//If an error occurs, display the message associated with the error.
catch (Exception err) {
      throw new Exception(err.getMessage());
    }
  }
//This method can be called to set the transcode. Synchronization is used so that
//only one thread at a time can call the method.
public synchronized void setTranscode(int newTranscode) throws Exception {
    if (newTranscode <= 0) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid trans code");
    }
    else {
      transcode = newTranscode;
    }
  }
  //This method can be called to set the item object. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized void setObject(Person newObject) throws Exception {
    if (newObject.equals("")) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid Object");
    }
    else {
      object  = newObject;
    }
  }
   //This method can be called to set the status of the transcode. Synchronization is
   //used so that only one thread at a time can call the method.
   public synchronized void setStatus(boolean newStatus) throws Exception {
    if (newStatus == false) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid Status");
    }
    else {
      status  = true;
    }
  }
    //This method can be called to get the transcode. Synchronization is used
    //so that only one thread at a time can call the method.
    public synchronized int gettranscode() {
    return transcode;
  }
  //This method can be called to get the item object. Synchronization is used so
  //that only one thread at a time can call the method.
  public synchronized Person getobject() {
    return object;
  }
  //This method can be called to get the status. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized boolean getstatus() {
    return status;
  }
}

[Joe Ess]

Originally posted by jon ladd:
Ok i am trying to get my add button working I had it compiling but now it just keep blowing up and I have no idea. I redid the code form the first example, for the most part.

The first compiler error I see is:
C:\crap\App.java:509: orphaned case
case FIND:{
Looks like you have an open brace following the case before FIND and you don't close it. No biggie. The 2 of the other 3 problems are missing semicolons. You have to pay attention to detail. And don't expect to write a ton of code and it will just work. Get something small to work and add to it. Helps narrow down where the problems are.

[jon ladd]

You must look at it differntly i make chages i just get more errors

[Joe Ess]

That's the unfortunate thing about computers. They do what you tell them to do, not what you WANT them to do.

[Ko Ko Naing]

Hi jon ladd,
It looks like your program is originated from another program, coz I saw a lot of stuff dealing with Items, Shipping and so on... R u trying to change someone's program to make yours with different topic? Or is it from your instructor? It seems like the whole program flow should be changed... I saw a lot of logical errors in the program....