A dialog box (“dialog” for short) is any box, or window, on the screen that you have a dialog with. You can decide to pop up some dialog boxes j to enter information in, or make choices about how a program works. “Other dialogs appear automatically to give you simple messages (such as “Your disk is full”) and ask you what you want to do about it.

Some people make a distinction between dialog boxes and alert boxes (where the computer warns you about something) or message boxes (where the computer just tells you about something), but that really only matters if you’re a programmer. Everyone will understand what you mean if you call them all dialog boxes.

import java.awt.*; 
 import java.awt.event.*; 
 import javax.swing.*; 
 public class JavaExampleOptionPane 
         { 
             public static void main( String aa[] ) 
                   { 
                     Object[] Btns = {"One", "Two", "Three", "Four" }; 
                      int Rspns =JOptionPane.showOptionDialog( null, "Message", "Option Pane In 
 Java",JOptionPane.YES_NO_CANCEL_OPTION,JOptionPane.PLAIN_MESSAGE, null,Btns, "One" ); 
                      String Typ = "Undefined"; 
                      if( Rspns == JOptionPane.YES_OPTION ) { Typ = "Yes"; } 
                      if( Rspns == JOptionPane.NO_OPTION ) { Typ = "No"; } 
                      if( Rspns == JOptionPane.CANCEL_OPTION ) { Typ = "Cancel"; } 
                      System.out.println( Typ + ": " + Rspns ); 
                   } 
        } 
 

[Read more…] about JColorChooser Panel Java Example

[Read more…] about JColorChooser Java Example

Sometimes a situation may arise when there are lots of components that cannot be accommodated in a single screen. In that case, tabbed pane is used to create tabs where each tab contains group of related components. When a particular tab is clicked, the components of that tab are displayed in the forefront. Tabbed pane is very common feature of GUI interfaces. It is commonly used in dialog boxes containing lots of commands. A tabbed pane is an object of JTabbedPane class.

Some of the constructors defined by JTabbedPane class are as follows:

JTabbedPane ()

JTabbedPane(int tabPlacement)

where,

tabPlacement specifies the position of tabs-can have one of the four values: TOP, BOTTOM, LEFT or RIGHT

[Read more…] about JTabbedPane Java Example

A confirmation dialog box is meant for asking a confirmation question and allows the user to give a yes/no/cancel response. It is created by using the static method showConfirmDialog() of JOptionPane. The general form of showConfirmDialog()method is

public static int showConfirmDialog(Component parentComponent,

Object message)

where,

parentComponent is the frame to which the dialog box is attached

message is the message to be displayed

[Read more…] about showConfirmDialog Java Example

An internal frame is similar to a regular frame which can be displayed within another window. It is a lightweight component which can be resized, closed, maximized or minimized depending upon the properties being set. It can also hold a title and a menu bar. An internal frame is an object of JinternalFrame class.

Some of the constructors defined by JinternalFrame class are as follows:

JinternalFrame()

JinternalFrame(String title)

JinternalFrame(String title, boolean resizable)

JinternalFrame(String title, boolean resizable, closable, boolean maximizable, boolean iconifiable)

where,

title specifies the title of the frame

resizable can have one of the two values: true, if the internal frame is resizable; otherwise false (default value)

closable can have one of the two values: true, if the internal frame is closeable, otherwise false (default value)

maximizable can have one of the two values: true, if the internal frame is maximizable, otherwise false (default value)

iconifiable can have one of the two values: true, if the internal frame is minimizable, otherwise false (default value)

The internal frame requires desktop pane which is capable of handling it. The purpose of desktop pane is to hold and manage the working of internal frames. A desktop pane is an object of JDesktopPane class and can be created by using its only constructor JDesktopPane ().

import javax.swing.*; 
 public class JInternalFrameJavaExample extends JFrame 
 { 
      public JInternalFrameJavaExample() 
     { 
        super(); 
     } 
     public static void main(java.lang.String[] args) 
     { 
         JInternalFrameJavaExample InternalFrame = new JInternalFrameJavaExample(); 
         InternalFrame.pack(); 
         InternalFrame.setSize(500, 200); 
         JInternalFrame IFrame = new JInternalFrame(); 
         IFrame.setVisible(true); 
         IFrame.setTitle("JInternalFrame Example"); 
         InternalFrame.getContentPane().add(IFrame); 
         InternalFrame.setTitle("JInternalFrame Example in Java Swing"); 
         InternalFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
         InternalFrame.setVisible(true); 
     } 
 } 
 

The following example is a simple demonstration of cut, copy, and paste String data type with a JTextArea. One thing you will notice is that the keyboard sequences normally used to cut, copy and paste also work. But if you look at any JTextField or JTextArea in any other program, you will find that these also support keyboard sequences clipboard automatically. this example simply adds programmatic control of the clipboard, and You can use these techniques if you want to capture text from the clipboard into something else than a JTextComponent.

Creating and added menu and JTextArea should by now seem a prosaic activity. What is different is the creation of the field Cboard Clipboard, which is done through Toolkit.

All actions take place in the listeners. The Copy and listeners Cut are the same except for the last line Cut, erasing the line has been copied. The two special lines are creating an object StringSelection the String and the call to setContents () with this StringSelection. All that is there is to put a String to the clipboard.

Paste, the data is removed from the clipboard using getContents (). What comes back is a fairly anonymous Transferable object, and it is uncertain actually it contains. One way to know is to call getTransferFlavors (), which returns an array of DataFlavor objects indicating that flavors are supported by this particular object. It You can also ask directly isDataFlavorSupported () passing the taste in which we are interested. Here, however, a bold strategy is used: getTransferData () is called assuming content supports the flavor of String, and if it does the problem is solved in the exception handler.

import javax.swing.*; 
 import java.awt.*; 
 import java.awt.event.*; 
 import java.awt.datatransfer.*; 
 public class ClipboardJavaExample extends JFrame 
 { 
        JMenuBar MenuBar = new JMenuBar(); 
        JMenu File = new JMenu("File"); 
        JMenu edit = new JMenu("Edit"); 
        JMenuItem cut = new JMenuItem("Cut"), 
                         copy = new JMenuItem("Copy"), 
                         paste = new JMenuItem("Paste"); 
        JTextArea TextArea = new JTextArea(20, 20); 
        Clipboard Cboard = getToolkit().getSystemClipboard(); 
        public ClipboardJavaExample() 
       { 
              cut.addActionListener(new Cut()); 
              copy.addActionListener(new Copy()); 
              paste.addActionListener(new Paste()); 
              edit.add(cut); 
              edit.add(copy); 
              edit.add(paste); 
              MenuBar.add(File); 
              MenuBar.add(edit); 
              setJMenuBar(MenuBar); 
              getContentPane().add(TextArea); 
        } 
        class Copy implements ActionListener 
       { 
             public void actionPerformed(ActionEvent e) 
            { 
                String selection = TextArea.getSelectedText(); 
                if (selection == null) 
                   return; 
                  StringSelection clipString =new StringSelection(selection); 
                  Cboard.setContents(clipString,clipString); 
             } 
       } 
             class Cut implements ActionListener 
            { 
                       public void actionPerformed(ActionEvent e) 
                      { 
                             String selection = TextArea.getSelectedText(); 
                             if (selection == null) 
                                  return; 
                                  StringSelection clipString = new StringSelection(selection); 
                                  Cboard.setContents(clipString, clipString); 
                                  TextArea.replaceRange("", TextArea.getSelectionStart(), TextArea.getSelectionEnd()); 
                       } 
             } 
            class Paste implements ActionListener 
           { 
                   public void actionPerformed(ActionEvent e) 
                  { 
                     Transferable clipData = Cboard.getContents(ClipboardJavaExample.this); 
                      try 
                     { 
                          String clipString = (String)clipData.getTransferData(DataFlavor.stringFlavor); 
                          TextArea.replaceRange(clipString,TextArea.getSelectionStart(),TextArea.getSelectionEnd()); 
                     }   catch(Exception ex) 
                               { 
                                    System.err.println("Not Working"); 
                               } 
                } 
           } 
                 public static void main(String[] args) 
                { 
                     JFrame frame = new ClipboardJavaExample(); 
                     frame.setTitle("Clipboard in Java Swing Example"); 
                     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
                     frame.setSize(320, 200); 
                     frame.setVisible(true); 
                     
                } 
 } 
 

A slider allows the user to enter a point moving data back and forth, which is intuitive in some situations (volume control, for example). a progress bar displays data in a relative form of “full” to “empty” so the user gets a perspective.

The key to hooking the two components together is to share your model in the line:
ProgressBar.setModel(Slider.getModel());
The JProgressBar is fairly straightforward, but the JSlider has a lot of options, such as orientation and major and minor brands.
Here is the example of Sliders and Progress bars

/* <applet code= Progress.class width=320 height=200> </applet> */ import javax.swing.*; 
 import java.awt.*; 
 import java.awt.event.*; 
 import javax.swing.event.*; 
 import javax.swing.border.*; 
 public class Progress extends JApplet 
 { 
            JProgressBar ProgressBar = new JProgressBar(); 
            JSlider Slider = new JSlider(JSlider.HORIZONTAL, 0, 100, 60); 
            public void init() 
           { 
                 Frame frm = (Frame)this.getParent().getParent(); 
                 frm.setTitle("Sliders and Progress bars"); 
                 Container container = getContentPane(); 
                 container.setLayout(new GridLayout(2,1)); 
                 container.add(ProgressBar); 
                 Slider.setValue(0); 
                 Slider.setPaintTicks(true); 
                 Slider.setMajorTickSpacing(20); 
                 Slider.setMinorTickSpacing(5); 
                 Slider.setBorder(new TitledBorder("Slide Bar (JSlider)")); 
                 ProgressBar.setModel(Slider.getModel()); 
                 container.add(Slider); 
           } 
 } 
 

Any component that can take text can also make HTML text , which will be formatted according to HTML rules. this means you can easily add text decorated in a Swing component. [Read more…] about HTML text on Swing Components Java Example

The java.awt.event.TextListener interface allows to react to changes the text contained in components of type TextField and TextArea. The addTextListener () method enables a text component to generate user events. the method TextValueChanged () receives events.

Its interface requires that the method be implemented textValueChanged whose associated event, java.awt.event.TextEvent, has a specific method interest listed below:

import java.awt.*; 
 import java.awt.event.*; 
 class JavaExampleTextEvent extends Frame implements TextListener 
 { 
   TextField Txt; 
   public JavaExampleTextEvent() 
     { 
       createAndShowGUI(); 
     } 
       private void createAndShowGUI() 
         { 
           setTitle("Example of Text Listener"); 
           setLayout(new FlowLayout()); 
           Txt=new TextField(20); 
           Txt.addTextListener(this); 
           add(Txt); 
           setSize(400,400); 
           setVisible(true); 
         } 
           public void textValueChanged(TextEvent Evnt) 
           { 
              setTitle(Txt.getText()); 
           } 
              public static void main(String aa[]) 
              { 
                 new JavaExampleTextEvent(); 
              } 
  } 
 

JSpinner: Selects a value from a range of possible options to Like the drop-down lists, but show no such list. values changed by pressing the scroll buttons. You can also enter a  value directly.

import java.awt.BorderLayout; 
 import java.awt.Color; 
 import java.awt.Container; 
 import java.awt.FlowLayout; 
 import java.awt.GridLayout; 
 import java.text.ParseException; 
 import java.util.Calendar; 
 import java.util.Date; 
 import javax.swing.BorderFactory; 
 import javax.swing.JFrame; 
 import javax.swing.JLabel; 
 import javax.swing.JPanel; 
 import javax.swing.JSpinner; 
 import javax.swing.SpinnerDateModel; 
 import javax.swing.SpinnerNumberModel; 
 import javax.swing.event.ChangeEvent; 
 import javax.swing.event.ChangeListener; 
 public class JavaExampleSpinner extends JFrame implements ChangeListener 
   { 
     JLabel LblQty; 
     JLabel LblDt; 
     JSpinner Spnr; 
     JSpinner DateSpnr; 
     JavaExampleSpinner(String Tytl) 
      { 
        setTitle(Tytl); 
        setSize(500,200); 
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        Container Cntnr=getContentPane(); 
        Cntnr.setLayout(new GridLayout(2,1)); 
        JPanel Pnl=new JPanel(); 
        Pnl.setLayout(new GridLayout(2,2)); 
        Pnl.setBorder(BorderFactory.createTitledBorder("Sale Entry")); 
        SpinnerNumberModel SpnrNmbrMdl=new SpinnerNumberModel(10,1,100,1); 
        Spnr=new JSpinner(SpnrNmbrMdl); 
        Spnr.addChangeListener(this); 
        Pnl.add(new JLabel("Select Quantity to Be Sold:")); 
        Pnl.add(Spnr); 
        Date Dt=new Date(); 
        SpinnerDateModel SpnrDtMdl=new SpinnerDateModel(Dt,null,null,Calendar.DATE); 
        DateSpnr=new JSpinner(SpnrDtMdl); 
        DateSpnr.setEditor(new JSpinner.DateEditor(DateSpnr,"dd:MM:yyyy")); 
        DateSpnr.addChangeListener(this); 
        Pnl.add(new JLabel("Select Sale Date:")); 
        Pnl.add(DateSpnr); 
        Cntnr.add(Pnl,BorderLayout.CENTER); 
        JPanel Panl=new JPanel(); 
        Panl.setLayout(new FlowLayout()); 
        LblQty=new JLabel(); 
        LblQty.setForeground(Color.GREEN); 
        LblDt=new JLabel(); 
        LblDt.setForeground(Color.RED); 
        Panl.add(LblQty); 
        Panl.add(LblDt); 
        Panl.setBorder(BorderFactory.createTitledBorder("Information")); 
        Cntnr.add(Panl);   
        setVisible(true); 
      } 
        public void stateChanged(ChangeEvent ee) 
         { 
            JSpinner JSpnr=(JSpinner)ee.getSource(); 
            try 
             { 
                JSpnr.commitEdit(); 
             } 
               catch(ParseException PrsEx){} 
               if(JSpnr==Spnr) 
               LblQty.setText("Quantity:"+JSpnr.getValue().toString()); 
               else if(JSpnr==DateSpnr) 
               LblDt.setText("Date:"+JSpnr.getValue().toString()); 
         } 
               public static void main(String[] aa) 
             { 
                    new JavaExampleSpinner("Example Date Spinner In Java"); 
                 } 
  } 
 

Slider in Swing is similar to scroll bar which allows the user to select a numeric value from a specified range of integer values. It has a knob which can slide on a range of values and can be used to select a particular value. For example, sliders are used in media players, to adjust volume, to set channel frequency, etc. Like scroll bars, they can also be horizontal or vertical. A slider is an object of class JSlider which is direct subclass of JComponent. The class JSlider also implements the interface SwingConstants.

      Constructors and methods of the JSlider class

The creation and display of the JSlider control is explained in Program.

import javax.swing.*; 
 import javax.swing.event.*; 
 import java.awt.*; 
 public class JavaExampleDynamicIcon 
   { 
     public static void main(String[] as) 
       { 
           final JSlider Wdth = new JSlider(JSlider.HORIZONTAL, 1, 150, 75); 
           final JSlider Hght = new JSlider(JSlider.VERTICAL, 1, 150, 75); 
           class DynamicIcon implements Icon 
             { 
                 public int getIconWidth() 
               { 
                   return Wdth.getValue(); 
               } 
                      public int getIconHeight() 
                    { 
                        return Hght.getValue(); 
                    } 
                           public void paintIcon(Component Cmpnt, Graphics gr, int a, int b) 
                        { 
                               gr.fill3DRect(a, b, getIconWidth(), getIconHeight(), true); 
                            } 
             }; 
                   Icon Icn = new DynamicIcon(); 
                  final JLabel LblDynmc = new JLabel(Icn); 
                  class Updater implements ChangeListener 
                 { 
                         public void stateChanged(ChangeEvent Evnt) 
                       { 
                               LblDynmc.repaint(); 
                           } 
                     }; 
                              Updater Updtr = new Updater(); 
                              Wdth.addChangeListener(Updtr); 
                              Hght.addChangeListener(Updtr); 
                              JFrame Frm = new JFrame(); 
                              Container Cntnr = Frm.getContentPane(); 
                              Cntnr.setLayout(new BorderLayout()); 
                              Cntnr.add(Wdth, BorderLayout.NORTH); 
                              Cntnr.add(Hght, BorderLayout.WEST); 
                              Cntnr.add(LblDynmc, BorderLayout.CENTER); 
                              Frm.setSize(210,210); 
                              Frm.setVisible(true); 
         } 
   } 
 

The java.awt.event.KeyListener interface, present in virtually all AWT component is used to respond to events triggered by  keystrokes when the focus is on the component. Allows the preprocessing  the input provided by the user and other sophisticated actions. its  interface requires the keyPressed, keyReleased method are implemented and  keyTyped. The associated event, java.awt.event.KeyEvent has the following methods  of particular interest are listed below:

import javax.swing.*; 
 import java.awt.*; 
 import java.awt.event.*; 
 public class JavaExampleKeyEvent extends JFrame implements KeyListener 
   { 
     private JLabel LblPrmpt = new JLabel("Press keys as Desired Below:"); 
     private JLabel LblOutPt = new JLabel("Key Typed is:"); 
     private JTextField Txt = new JTextField(10); 
     public JavaExampleKeyEvent() 
      { 
        setTitle("Java Example of Key Event"); 
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        setLayout(new BorderLayout()); 
        add(LblPrmpt,BorderLayout.NORTH); 
        add(Txt, BorderLayout.CENTER); 
        add(LblOutPt,BorderLayout.SOUTH); 
        addKeyListener(this); 
        Txt.addKeyListener(this); 
      } 
        public void keyTyped(KeyEvent Evnt) 
         { 
           char s = Evnt.getKeyChar(); 
           LblOutPt.setText("Last key Pressed:" + s); 
         } 
           public void keyPressed(KeyEvent Evnt) 
            { 
            } 
              public void keyReleased(KeyEvent Evnt) 
              { 
              } 
                public static void main(String[] ar) 
                 { 
                   JavaExampleKeyEvent Frm = new JavaExampleKeyEvent(); 
                   final int WIDTH = 250; 
                   final int HEIGHT = 100; 
                   Frm.setSize(300,300); 
                   Frm.setVisible(true); 
                 } 
   } 
 

The java.awt.event.ItemListener interface is responsible for processing events  java.awt.event.ItemEvent action generated by the activation of checkboxes (Checkbox), option buttons (CheckboxGroup) and items in menus option type  (CheckboxMenuItem). Its implementation requires the inclusion of the method  itemStateChanged these classes.

import java.awt.*; 
 import javax.swing.*; 
 import java.awt.event.*; 
 public class JavaExampleCheckBox extends JFrame implements ItemListener 
 { 
     FlowLayout Flw = new FlowLayout(); 
     JLabel LblChc = new JLabel("What would you like to Choose?"); 
     JCheckBox Cappuccino = new JCheckBox("Coffee", false); 
     JCheckBox SoftDrink = new JCheckBox("Pepsi", false); 
     JCheckBox Mlk = new JCheckBox("Milk", false); 
     JCheckBox Wtr = new JCheckBox("Water", false); 
     String Outpt,InsChsn; 
     public JavaExampleCheckBox() 
      { 
        super("Java Example Of Check Box Function"); 
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        setLayout(new FlowLayout()); 
        LblChc.setFont(new Font("Times New Roman", Font.ITALIC, 22)); 
        Cappuccino.addItemListener(this); 
        SoftDrink.addItemListener(this); 
        Mlk.addItemListener(this); 
        Wtr.addItemListener(this); 
        add(LblChc); 
        add(Cappuccino); 
        add(SoftDrink); 
        add(Mlk); 
        add(Wtr); 
      } 
            public void itemStateChanged(ItemEvent Chk){} 
             public static void main(String[] aa) 
             { 
               final int FRAME_WIDTH = 330; 
               final int FRAME_HEIGHT = 110; 
               JavaExampleCheckBox Frm =new JavaExampleCheckBox(); 
               Frm.setSize(FRAME_WIDTH, FRAME_HEIGHT); 
               Frm.setVisible(true); 
             } 
 } 
 

The java.awt.event.ActionListener interface is responsible for processing events java.awt.event.ActionEvent action generated by the drive buttons (Button), selection items (MenuItem) in suspended (drop-down) or independent menus (popup) at Pressing the “Enter” in inboxes (TextField) and double-click boxes list (List). Its implementation requires the inclusion of the actionPerformed method in these classes.

As a complement, the ActionEvent event has the following specific methods associated with:

import javax.swing.*; 
 import java.awt.*; 
 import java.awt.event.*; 
 public class JavaExampleHello2JApplet extends JApplet implements ActionListener 
  { 
    JLabel LblGrtng = new JLabel("Hi Welcome...!Who are you?"); 
    Font FntOne = new Font("Times New Roman", Font.BOLD, 36); 
    Font FntTwo = new Font("Times New Roman", Font.ITALIC, 48); 
    JTextField TxtAns = new JTextField(10); 
    JButton BtnClck = new JButton("Click Here"); 
    JLabel LblPrsnlGrtng = new JLabel(" "); 
    Container Cntnr = getContentPane(); 
    public void init() 
     { 
       LblGrtng.setFont(FntOne); 
       LblPrsnlGrtng.setFont(FntTwo); 
       Cntnr.add(LblGrtng); 
       Cntnr.add(TxtAns); 
       Cntnr.add(BtnClck); 
       Cntnr.setLayout(new FlowLayout()); 
       Cntnr.setBackground(Color.CYAN); 
       BtnClck.addActionListener(this); 
       TxtAns.addActionListener(this); 
     } 
       public void actionPerformed(ActionEvent ee) 
       { 
         String Nme = TxtAns.getText(); 
         Cntnr.remove(LblGrtng); 
         Cntnr.remove(BtnClck); 
         Cntnr.remove(TxtAns); 
         LblPrsnlGrtng.setText("Hello, " + Nme + "! "); 
         Cntnr.add(LblPrsnlGrtng); 
         Cntnr.setBackground(Color.WHITE); 
         validate(); 
       } 
 } 
 /*<applet code= JavaExampleHello2JApplet.class Height=300 width=240></applet>*/ 
 

JOptionPane is a subclass of JComponent which includes static methods for creating and customizing modal dialog boxes using a simple code. Previously, you have seen that creating a dialog box using JDialog makes the code cumbersome. So JOptionPane is used instead of JDialog to minimize the complexity of the code. JOptionPane displays the dialog boxes with one of the four standard icons (question, information, warning, and error) or the custom icons specified by the user.

Some of the constructors defined by the JOptionPane class are as follows.

JOptionPane ()

JOptionPane(Object message)

JOptionPane(Object message, int messageType)

JOptionPane(Object message, int messageType, int optionType)

JOPtionPane (Object message, int messageType, int optionType, Icon icon)

JOPtionPane (Object message, int messageType, int optionType, Icon icon, Object[] options)

JOPtionPane (Object message, int messageType, int optionType, Icon icon, Object[] options, Object initialValue)

where,

message is the message to be displayed in the dialog box

messageType specifies the type of the message to be displayed. It has various values which are represented as: ERROR_MESSAGE, INFORMATION_MESSAGE,WARNING_MESSAGE, QUESTION_MESSAGE or PLAIN_MESSAGE

optionType is used to specify the options. It can have various values which are represented as: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION or OK_CANCEL_OPTION icon specifies the icon to be displayed

options is an array of options to be displayed in the dialog box with none of them selected

initialValue specifies the default option selected from the list provided in options

JOptionPane class is used to display four types of dialog boxes namely, 

● MessageDialog – dialog box that displays a message making it possible to add icons to alert the user.
● ConfirmDialog – dialog box that besides sending a message, enables the user to answer a question.
● InputDialog – dialog box that besides sending a message, allows entry of a text.
● OptionDialog – dialog box that covers the three previous types.

import javax.swing.JOptionPane; 
 public class JavaExampleOptionPaneSalaryDialog 
   { 
     public static void main(String[] aa) 
      { 
        String StrngWg, StrngDpndnt; 
        double Salary,WklyPay; 
        int Dpndnts; 
        final double HOURS_IN_WEEK = 37.5; 
        StrngWg = JOptionPane.showInputDialog(null,"Enter Worker's Hourly Wage", "First Salary Dialog",JOptionPane.INFORMATION_MESSAGE); 
        WklyPay = Double.parseDouble(StrngWg) *HOURS_IN_WEEK;StrngDpndnt = JOptionPane.showInputDialog(null,"How many Dependents?", "Second Salary Dialog 
 ",JOptionPane.QUESTION_MESSAGE); 
        Dpndnts = Integer.parseInt(StrngDpndnt); 
        JOptionPane.showMessageDialog(null,"Weekly Pay is $" +WklyPay+ "\nDeductions will be made for :" +Dpndnts+ "Dependents"); 
      } 
   } 
 

The option dialog box provides the feature of all the above three discussed dialog boxes. It is created by using the static method showOptionDialog () of JOptionPane. The general form of showOptionDialog () method is

public static int showOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue))

where,

parentComponent is the frame in which the dialog box is displayed

message is the message to be displayed

title is a string of text to be displayed in the title bar of the dialog box

optionType specifies options available on the dialog box such as YES_NO_OPTION or YES_NO_CANCEL_OPTION

messageType specifies the type of message such as error message, information message, warning message, question message or plain message

icon specifies the icon on the dialog box

options allows the user to use components other than buttons

initialValue determines the initial choice

import java.util.*; 
 import javax.swing.*; 
 public class JavaExampleAgeCalculator 
   { 
     public static void main(String[] as) 
      {        
                GregorianCalendar Current = new GregorianCalendar(); 
        int CrntYear; 
        int YearofBrth; 
        int YrsOld; 
        YearofBrth = Integer.parseInt(JOptionPane.showInputDialog(null,"In Which year You Were born?")); 
        CrntYear = Current.get(GregorianCalendar.YEAR); 
        YrsOld = CrntYear - YearofBrth;JOptionPane.showMessageDialog(null,"At Present year you become " + YrsOld +" Years Old"); 
      } 
   }