0
爲什麼字符串「getPriceDisplay」不出現在我的JTextField，totalTextField？爲什麼字符串「getPriceDisplay」不出現在我的JTextField中，「totalTextField」？
// NamesFrame.java
//
// Informatics 45 Spring 2010
// Code Example: GridBagLayouts, JLists, and ListModels
// Version 2
//
// This version of NamesFrame employs model/view separation. In order to
// do it, it stores a NameCollection (our model) instead of a DefaultListModel,
// then implements its own custom ListModel that knows how to handle event
// notifications from NameCollection and turn them into events that JLists
// can handle.
package inf45.spring2010.examples.gui3;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MenuFrame extends JFrame
{
private MenuCollection menu;
private JList menuList;
private JTextField newNameField;
private JList orderList;
private JButton orderButton, cancelButton;
private JTextField totalText;
private JTextField inputText;
DefaultListModel dm = new DefaultListModel();
public menuItem[] mi;
private double getPrice;
private String getPriceDisplay;
menuItem [] menuArray = new menuItem [13];
public MenuFrame()
{
menu = new MenuCollection();
setTitle("Senor Club");
setSize(1000, 1000);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
menuArray[0] = new menuItem("Cheese Enchilada", 2.95, true);
menuArray[1]= new menuItem ("Chicken Enchilada", 3.59, true);
menuArray[2]= new menuItem ("Beef Taco", 1.69, true);
menuArray [3]= new menuItem ("Chicken Taco", 1.89, true);
menuArray [4] = new menuItem ("Fish Taco", 2.39, true);
menuArray [5] = new menuItem ("Bean and Cheese Burrito", 3.19, true);
menuArray [6] = new menuItem ("Chicken Burrito", 5.49, true);
menuArray [7] = new menuItem ("Steak Burrito", 6.49, true);
menuArray [8] = new menuItem ("Carnitas Burrito", 6.79, true);
menuArray [9] = new menuItem ("Chips and Salsa", .99, true);
menuArray [10] = new menuItem ("Guacamole", 2.49, false);
menuArray [11] = new menuItem ("Small Drink", 1.45, false);
menuArray [12] = new menuItem ("Large Drink", 1.95, false);
mi = menuArray;
buildUI();
}
// All of the layout code has stayed the same. The only difference in
// this method is where we create the list model; instead of creating a
// DefaultListModel (which stores its own data), we create a NamesListModel,
// our own custom list model that knows how to interact with the
// NameCollection.
private void buildUI()
{
GridBagLayout layout = new GridBagLayout();
getContentPane().setLayout(layout);
NamesListModel listModel = new NamesListModel(menu);
menuList = new JList(menuArray);
menuList.addMouseListener(new MouseAdapter()
{
@Override
public void mousePressed(MouseEvent e)
{
Object selected = menuList.getSelectedValue();
System.out.println("menuList.addMouseListener.mousePressed selected=" + selected);
DefaultListModel dm = (DefaultListModel) orderList.getModel();
dm.add(orderList.getModel().getSize(), selected);
for (int i = 0; i < menuArray.length; i++){
if (selected.equals(mi[i].getItemName())) {
getPrice = mi[i].getItemPrice();
}
}
getPriceDisplay = Double.toString(getPrice);
getPriceDisplay = totalText.getText();
totalText = new JTextField(getPriceDisplay);
}
});
orderList = new JList(dm);
JScrollPane orderListScrollPane = new JScrollPane(orderList);
getContentPane().add(orderListScrollPane);
layout.setConstraints(
orderListScrollPane,
new GridBagConstraints(
1, 1, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 10, 5, 10), 0, 0));
JScrollPane menuListScrollPane = new JScrollPane(menuList);
getContentPane().add(menuListScrollPane);
layout.setConstraints(
menuListScrollPane,
new GridBagConstraints(
0, 1, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 10, 5, 10), 0, 0));
JScrollPane recieptListScrollPane = new JScrollPane();
getContentPane().add(recieptListScrollPane);
layout.setConstraints(
recieptListScrollPane,
new GridBagConstraints(
3, 1, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 10, 5, 10), 0, 0));
totalText = new JTextField();
Font font = new Font("Verdana", Font.BOLD, 30);
totalText.setFont(font);
totalText.setForeground(Color.RED);
getContentPane().add(totalText);
layout.setConstraints(
totalText,
new GridBagConstraints(0, 3, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 5, 5, 10), 0, 0));
inputText = new JTextField();
Font inputFont = new Font("Verdana", Font.BOLD, 30);
totalText.setFont(inputFont);
totalText.setForeground(Color.RED);
getContentPane().add(inputText);
layout.setConstraints(
inputText,
new GridBagConstraints(
1, 3, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 10, 5, 10), 0, 0));
JButton payLabel = new JButton("Pay");
getContentPane().add(payLabel);
layout.setConstraints(
payLabel,
new GridBagConstraints(
3, 3, 2, 1, 1.0, 1.0,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
new Insets(5, 10, 5, 10), 0, 0));
orderButton = new JButton("Order");
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
}
};
getContentPane().add(orderButton);
layout.setConstraints(
orderButton,
new GridBagConstraints(
0, 2, 1, 1, 0.5, 0.0,
GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,
new Insets(5, 10, 5, 5), 0, 0));
cancelButton = new JButton("Cancel");
//addButton.addActionListener(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
cancelPressed();
}
};
getContentPane().add(cancelButton);
layout.setConstraints(
cancelButton,
new GridBagConstraints(
1, 2, 1, 1, 0.0, 0.0,
GridBagConstraints.EAST, GridBagConstraints.NONE,
new Insets(5, 5, 5, 10), 0, 0));
}
// In this method, we add the new name to the NameCollection instead of
// adding it directly to the list model. This sets off a chain of events:
//
// * NameCollection notifies its listener, the NamesListModel, that a name
// has been added.
// * NamesListModel notifies its listener, the JList, that an "interval"
// (a subsequence of the elements) has changed.
// * JList redraws the affected elements (if they're visible).
//
private void addName()
{
String newName = newNameField.getText().trim();
if (newName.isEmpty())
{
JOptionPane.showMessageDialog(
this, "No name was specified. Please enter a name.", "No Name Specified",
JOptionPane.ERROR_MESSAGE);
}
else
{
menu.add(newName);
newNameField.setText("");
}
}
// In this method, we remove the name from the NameCollection instead of the
// list model, which sets off the same chain of events that addName() does.
// This is a custom list model. It extends AbstractListModel, which
// provides a basic implementation of some of the ListModel functionality,
// while leaving the important parts of it (namely, how to figure out how
// large the collection is and how to get an element from the collection)
// unimplemented; this class implements those two elements, which are
// called getSize() and getElementAt().
//
// Our list model also implements the NameCollectionChangedListener
// interface, so that it can receive change events from the NameCollection.
// It's legal in Java for a class to extend another class and implement
// an interface. (In fact, it's legal for a class to extend a class and
// implement multiple interfaces, if you're so inclined.) It's not legal,
// however, for a class to extend multiple other classes.
private class NamesListModel
extends AbstractListModel
implements NameCollectionChangedListener
{
// The list model will operate on the collection, so we'll need to
// store a reference to the collection inside the list model.
private MenuCollection collection;
// When we create the list model, we need to store the collection
// and register the list model as a listener on the collection,
// so that whenever the collection is changed, the list model
// will be notified.
public NamesListModel(MenuCollection collection)
{
this.collection = collection;
collection.addNameCollectionChangedListener(this);
}
// This is the method that will be called whenever the NameCollection
// has a name added to it. What it does is fire an "interval added"
// event, which is how it tells its JList that some subsequence of
// elements has changed. The three parameters are (1) who sent the
// event, (2) where the sequence of changed elements begins, and
// (3) where the sequence of changed elements ends. In our case, the
// sequence of changed elements is just the one element, so we say
// "index" in both places; why the method specifies the beginning and
// end separately is so that you can cheaply add, say, 10 elements
// without having to fire 10 events.
public void nameAdded(int index)
{
fireIntervalAdded(this, index, index);
}
// This is the method that will be called whenever the NameCollection
// has a name removed from it. It does something similar to nameAdded(),
// except that it notifies its JList about the removal of an element,
// appropriately, instead of the addition of an element.
public void nameRemoved(int index)
{
fireIntervalRemoved(this, index, index);
}
// Whenever the JList asks the list model how many elements there are
// in the list, the list model will just ask the collection "How many
// names have you got?"
public int getSize()
{
return collection.getSize();
}
// Whenever the JList asks the list model what element is at a
// particular index, the list model will just ask the collection
// "What name is at this index?"
public Object getElementAt(int index)
{
return collection.get(index);
}
}
private void cancelPressed()
{
dispose();
}
public void addMenu()
{
}
}