class JOptionPane

Intro

While it will take some more understanding of classes and other language concepts to fully dig into many Swing components and containers, JOptionPane is an easy one that we can use right away
class JOptionPane: API Description
JOptionPane is a class library that makes it easy to pop up a simple dialog box that either provides an information message or asks for a simple input from the user
While the class has a lot of methods, most uses of this class are through a few static methods
- Remember that this means you can call upon such features through the class name, without having to build objects

Simple Dialog Box types

Message dialog box
- This is a simple information dialog box
- To use it, call one of the showMessageDialog() methods
- These are void methods, so just call them by themselves to pop up a message box
Input dialog box
- This is a dialog box that allows a user to type in some input
- To use it, call one of the showInputDialog() methods
- These methods return the input as a String. Such calls should capture the returned value
Confirm dialog box
- This is a dialog box that presents the user with a Yes/No/Cancel option
- To use it, call one of the showConfirmDialog() methods
- These methods return the user's answer as an int value.
- The returned integer value can be tested against pre-defined constants, shown in the Field Summary for the class

A few simple things about Strings

You can assign a string literal to a variable of type String:

  String s1, s2, s3;
  s1 = "Hello World";
  s2 = "Goodbye";
  s3 = "World";

Just like we can concatenate strings inside of print calls, we can concatenate strings anywhere -- with literals and with String variables:
```
  String s4 = s2 + ' ' + s3;	// s4 now stores "Goodbye World"
```
There is also a static method in class String called format(). You can use this to return a string that uses printf style formatting. Example:
```
  String s5;
  s5 = String.format("Pi to 3 decimal places = %.3f", Math.PI);
```

Using message dialogs

There are three versions of showMessageDialog()

  void showMessageDialog(Component parentComponent, Object message) 

  void showMessageDialog(Component parentComponent, Object message, 
                                   String title, int messageType) 

  void showMessageDialog(Component parentComponent, Object message, 
                                   String title, int messageType, Icon icon)

The parameters:
1. parentComponent: indicates what component this dialog will pop up over. Use null to make the message not connected to any other component
2. message: This is the actual message being displayed.
3. title: The string that will appear in the pop-up window's title bar
4. messageType: Use one of these static constants from the class. Except for plain message, each one uses a special icon on the message box
  - PLAIN_MESSAGE
  - ERROR_MESSAGE
  - INFORMATION_MESSAGE
  - WARNING_MESSAGE
  - QUESTION_MESSAGE
5. icon: A custom icon to use
Note that all calls use the first two parameters. The others can be used optionally
Try this sample program

Using input dialogs

There are several versions of showInputDialog. Some of these have very similar options as the showMessageDialog methods
However, the easiest form is simply to pass in a message prompt as a single parameter. Example:
```
  String s1;
  s1 = JOptionPane.showInputDialog("Please enter an integer:");
```
Note that in the above call, we captured the return value into a variable. The showInputDialog call will always return the entered value
Also note that this value always comes back as a String
If you want to save the entered data as a different type, you will need to convert it

Converting Strings to primitive types

Each primitive type has a corresponding class in java.lang
Each of these classes has a static method that does a type conversion from String to the appropriate type

Example:

  String s1;
  s1 = JOptionPane.showInputDialog("Please enter an integer:");

  int value = Integer.parseInt(s1);	// converts s1 into an integer

The table below lists the class that goes along with the primitive type, as well as the conversion method

Primitive type	Corresponding wrapper class	static conversion method
`boolean`	`Boolean`	`boolean parseBoolean(String)`
`byte`	`Byte`	`byte parseByte(String)`
`short`	`Short`	`short parseShort(String)`
`int`	`Integer`	`int parseInt(String)`
`long`	`Long`	`long parseLong(String)`
`float`	`Float`	`float parseFloat(String)`
`double`	`Double`	`double parseDouble(String)`

Example program showing inputs

Using confirm dialogs

There are several versions of showConfirmDialog. Most of these have very similar options as the showMessageDialog methods
Parameters: All calls use the first two. Others are optional
1. parentComponent: Same as for message dialogs
2. message: Same as for message dialogs
3. title: Same as for message dialogs
4. optionType: Can be one of these static class constants:
  - YES_NO_OPTION
  - YES_NO_CANCEL_OPTION
  - OK_CANCEL_OPTION
5. messageType: Same as for message dialog
6. icon: Same as for message dialog
These methods each return an integer value. That value can be captured, and then compared against one of the following static constants, to determine which one was selected:
- YES_OPTION
- NO_OPTION
- CANCEL_OPTION
- OK_OPTION

Sample call:

  int ans = JOptionPane.showConfirmDialog(null, "Are you a good student?",
                        "Student query", JOptionPane.YES_NO_OPTION);

  if (ans == JOptionPane.YES_OPTION)
     JOptionPane.showMessageDialog(null, "Hurrah!  A good student!");
  else
     JOptionPane.showMessageDialog(null, "Not another bad student!");

Sample program that illustrates some Confirm Dialog boxes