Unit -1

Java Swing

Q1) What is javabeans?

A1) JavaBeans is a platform-agnostic, portable model developed in the Java programming language. Beans are the components that make it up.

JavaBeans, to put it simply, are classes that encapsulate several objects into a single object. It facilitates access to these objects from a variety of locations. Constructors, Getter/Setter Methods, and other features are included in JavaBeans.

There are a few JavaBeans conventions that should be followed:

●      A default constructor should be available for beans (no arguments).

●      Getter and setter methods should be available in beans.

●      To read the value of a readable property, a getter method is utilized.

●      A setter method should be used to update the value.

●      JavaBeans should implement java.io.serializable because it allows you to save, store, and restore the state of the JavaBean you're dealing with.

A JavaBean is a Java class that must adhere to the following rules:

●      It should have a constructor that takes no arguments.

●      Serializable is a must.

●      It should include getter and setter methods for setting and retrieving the values of properties.

Q2) Write the advantages of javabeans?

A2) Advantages

The following are some of Java Beans benefits:

●      Portable: Because JavaBeans are written entirely in Java, they can run on any platform that supports the Java Run-Time Environment. The Java Virtual Machine implements all platform-specific features, as well as JavaBeans support.

●      Compact and Easy: Components made with JavaBeans are simple to design and use. The JavaBeans architecture places a strong emphasis on this area. Writing a simple Bean does not need much work. Furthermore, because a bean is light, it does not need to carry a lot of inherited baggage to maintain the bean's environment.

●      Carries the Strengths of the Java Platform: There isn't any new sophisticated process for registering components with the run-time system in JavaBeans, so it's very compatible.

●      Another program can access the JavaBean properties and methods.

●      It makes reusing software components much easier.

Q3) Write the properties of javabeans?

A3) Properties

A JavaBean property is a named feature that the user of the object can access. The feature can be any Java data type, and it must contain the classes you specify.

A property on a JavaBean can be read, write, read-only, or write-only. Two methods in the JavaBean's implementation class are used to access JavaBean features:

1. GetPropertyName () - For example, if the property is called firstName, the method to read it is called getFirstName(). The accessor is the name for this procedure.
2. SetPropertyName () - For example, if the property name is firstName, the method to write that value is setFirstName(). The mutator is the name of this approach.

Q4) Write about JFrame?

A4) JFrame

The javax.swing package. The JFrame class is a container that inherits the java.awt package. Frame is a type of class. JFrame functions similarly to a main window, allowing users to add components such as labels, buttons, and text fields to construct a graphical user interface.

JFrame, unlike Frame, allows you to hide or close the window using the setDefaultCloseOperation(int) method.

Nested class

Constructor

Fields

Q5) Write any simple example of JFrame?

A5) Example

Import java.awt.FlowLayout; 

Import javax.swing.JButton; 

Import javax.swing.JFrame; 

Import javax.swing.JLabel; 

Import javax.swing.JPanel; 

Public class JFrameExample { 

    public static void main(String s[]) { 

        JFrame frame = new JFrame("JFrame Example"); 

        JPanel panel = new JPanel(); 

        panel.setLayout(new FlowLayout()); 

        JLabel label = new JLabel("JFrame By Example"); 

        JButton button = new JButton(); 

        button.setText("Button"); 

        panel.add(label); 

        panel.add(button); 

        frame.add(panel); 

        frame.setSize(200, 300); 

        frame.setLocationRelativeTo(null); 

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

        frame.setVisible(true); 

    } 

} 

Output

Q6) Describe JDialog?

A6) The JDialog control depicts a top-level window with a border and a title that is used to receive user input. It is a descendant of the Dialog class.

It lacks the maximize and minimize buttons found in JFrame.

JDialog class declaration

Let's look at the javax.swingjavax.swing.JDialog class. Declaration.

Public class JDialog extends Dialog implements WindowConstants, Accessible, RootPaneContainer 

Constructor

Example

Import javax.swing.*; 

Import java.awt.*; 

Import java.awt.event.*; 

Public class DialogExample { 

    private static JDialog d; 

    DialogExample() { 

        JFrame f= new JFrame(); 

        d = new JDialog(f , "Dialog Example", true); 

        d.setLayout( new FlowLayout() ); 

        JButton b = new JButton ("OK"); 

        b.addActionListener ( new ActionListener() 

        { 

            public void actionPerformed( ActionEvent e ) 

            { 

                DialogExample.d.setVisible(false); 

            } 

        }); 

        d.add( new JLabel ("Click button to continue.")); 

        d.add(b);  

        d.setSize(300,300);   

        d.setVisible(true); 

    } 

    public static void main(String args[]) 

    { 

        new DialogExample(); 

    } 

} 

Output

Q7) What is JTextField?

A7) JTextField creates a single-line editable text field. In the box, a user can type unformatted content. Call the function of the text field and supply an optional integer parameter to it to initialize it. This property determines the box's width based on the number of columns. The number of characters that can be entered in the box is unrestricted.

A  JTextField class object is a text component that allows you to change a single line of text. It is a descendant of the JTextComponent class.

JTextField class declaration

Public class JTextField extends JTextComponent implements SwingConstants 

Constructor

This class has the following constructors:

●      JTextField(): These are the constructors that are in charge of making a new TextField.

●      JTextField(int columns): The parameter columns are used to indicate the column numbers in a new empty TextField, as the name implies.

●      JTextField(String text): JTextField(String text): JTextField(Str The text argument is used to represent a provided string that has been initialized with a new empty text field.

●      JTextField(String text, int columns): This function Object() { [native code] } is used to create an empty text field with the supplied number of columns and the string provided.

●      JTextField(Document doc, String text, int columns): This is used to use the supplied storage model and number of columns.

Methods of JTextField

Let's have a look at some of the most important methods in the JTextField class in Java.

●      setColumns(int n): This method is used to set the number of columns in a text field to the supplied number.

●      setFont(Font f): This function displays and sets the font of the displayed text in the text field.

●      addActionListener(ActionListener I): This method is used to set the action listener to the text field. 

●      Int getColumns(): The column numbers in the text field are obtained using the int getColumns() function.

Q8) Write any example of JTextField?

A8) Example

Import javax.swing.*;

Import java.io.*;

Class TextEg

{

Public static void main(String args[])  throws IOException

{

JFrame f= new JFrame("Example of TextField ");

//variable declaration

JTextField t12,t22;

t12=new JTextField("Welcome!");

t12.setBounds(10,100, 100,30);

//declaring new example

t22=new JTextField("new example");

//setting bounds

t22.setBounds(10,150, 100,30);

//adding into frames

f.add(t12); f.add(t22);

f.setSize(200,200);

f.setVisible(true);

}

}

Output

Q9) Write about JTextArea?

A9) JTextArea

The JTextArea class is used to create a multi-line text box. A user can enter non-formatted text in the field, much like in the JTextField. JTextArea's  additionally expects two integer parameters that define the text-height area's and width in columns. It has no limit on how many characters the user can type in the text-area.

A multi-line zone that displays text is the object of the JTextArea class. It allows you to alter numerous lines of text. It is a descendant of the JTextComponent class.

JTextArea class declaration

Public class JTextArea extends JTextComponent 

Constructor

Let's take a closer look at the various sorts of constructors:

●      JTextArea(): This is used to create a new text-based blank space.

●      JTextArea(int row, int column): This JTextArea is similar to the unparameterized JTextArea, except it uses the rows and column arguments instead. It's used to create a new text field-based area with a set of rows and columns.

●      JTextArea(String s): JTextArea(Str It's used to create a new text-based region from a provided starting text.

●      JTextArea(String s, int row, int column): This generates a given initial text and a specified number of rows and column values, comparable to those having string values or those containing row and column parameterized values.

Methods

Let us read some of the primary methods that form the foundation of the JTextArea in Java after we've gone over the numerous constructors connected to JTextArea.

●      Append(String s): This method is used to append one specified string to the text in the text area, as the name implies.

●      setFont(Font f): This method sets the font size and type of the text area to the specified font.

●      getLineCount(): Gets the number of lines in the text area text field with this function.

●      setColumns(int c): This is used to set the text area's column number as well as the specified integer.

●      setRows(int r): This function is used to set the text area's rows as well as the specified integer.

●      getColumns(): This function returns the number of columns in addition to the text area field.

●      getRows(): is a function that returns the number of rows in a specific text area.

Q10) Write any example of JTextArea?

A10) Example

//importing basic packages and relevant classes

Import java.io.*;

Import java.awt.*;

Import javax.swing.*;

Import java.awt.event.*;//defining a class TxtEG

Class TxtEG

{

//calling a default constructor after creation

TxtEG(){

//creation of frames with the object f

JFrame f= new JFrame();

// creation of a JTextArea

JTextArea area=new JTextArea("Welcome");

//setting boundary

Area.setBounds(10,30, 200,200);

//adding properties to the frame

f.setVisible(true);

f.setSize(300,300);

f.add(area);

f.setLayout(null);

}

//declaring method main

Public static void main(String args[]) throws IOException

{

New TxtEG();

}

}

Output

Q11) Write about JButton?

A11) The JButton class is used to construct a UI push-button. The button can have some text or an image displayed on it. When clicked and double-clicked, it triggers an event. One of the constructors of a JButton might be called in the programme to implement it.

The JButton class is used to create a labeled button that can be implemented on any platform. When the button is pressed, the application performs some action. It is a descendant of the AbstractButton class.

JButton class declaration

Public class JButton extends AbstractButton implements Accessible 

Constructor

●      JButton(): It generates a button that is devoid of text and an icon.

●      JButton(String s): It produces a button with the text you choose.

●      JButton(Icon i): It generates a button with the icon object supplied.

Methods

The methods in JButton Class that are most regularly used are listed below:

●      setText(string text): This method is used to set the specified text on the component's button.

●      getText(): This function returns the text of the button in the specified component as a string.

●      Void setEnabled(boolean b): method is used to enable or deactivate a button by giving the appropriate value in the parameter.

●      Void setIcon(icon i):  This method is used to set the specified icon "I" to the button.

●      Icon getIcon(): This function returns the icon associated with the provided button.

●      Void setHorizontalTextPosition(int hpos): This method is used to set the horizontal position of the button message in relation to its icon.

●      Void stVerticalTextPosition(int vpos): This method sets the vertical position of the button message in relation to its icon.

Q12) Write any simple example of JButton?

A12) Example

Import javax.swing.*;   

Public class ButtonExample { 

Public static void main(String[] args) { 

    JFrame f=new JFrame("Button Example"); 

    JButton b=new JButton("Click Here"); 

    b.setBounds(50,100,95,30); 

    f.add(b); 

    f.setSize(400,400); 

    f.setLayout(null); 

    f.setVisible(true);  

} 

} 

Output

Q13) Write about JComboBox?

A13) JComboBox is a component of the Java Swing framework. It is an extension of the JComponent class. JComboBox is represented as a popup menu that contains a list of elements from which the user can choose an option or element. Depending on the necessity and the coder, it can be modifiable or not. It is not editable by default because it combines the features of a button and a drop-down list. A text box and a drop-down list are included in the JComboBox, which is not editable. Users can type or can click on the arrow button to view the drop-down list. Combo Boxes require less space and hence are very useful when size is small or limited.

JComboBox class declaration

Public class JComboBox extends JComponent implements ItemSelectable, ListDataListener, ActionLis

JComboBox Constructors

The following are some of the most regularly used constructors:

●      JComboBox(): It produces a new empty JComboBox with the default data model.

●      JComboBox(Object[] items): This method produces a new JComboBox containing the elements from the supplied array.

●      JComboBox(Vector<?> items): It builds a new JComboBox with the elements listed in the specified vector.

●      JComboBox(ComboBoxModel M): This method produces a JComboBox with the items provided in the ComboBoxModel given.

Methods

●      void addItem(Object anObject): It's used to add a new item to the list of items.

●      void removeItem(Object anObject): It's used to remove something from the item list.

●      void removeAllItems(): It is used to clear the list of all things.

●      void setEditable(boolean b): It determines whether the JComboBox can be edited.

●      void addActionListener(ActionListener a): It's where you'll put the ActionListener.

●      void addItemListener(ItemListener i): It's where you'll put the ItemListener.

Example

Import javax.swing.*;   

Public class ComboBoxExample {   

JFrame f;   

ComboBoxExample(){   

    f=new JFrame("ComboBox Example");   

    String country[]={"India","Aus","U.S.A","England","Newzealand"};       

    JComboBox cb=new JComboBox(country);   

    cb.setBounds(50, 50,90,20);   

    f.add(cb);       

    f.setLayout(null);   

    f.setSize(400,500);   

    f.setVisible(true);        

}   

Public static void main(String[] args) {   

    new ComboBoxExample();        

}   

}  

Output

Q14) Describe JLabel?

A14) JLabel is one of the numerous Java Swing classes available. The swing package's JLabel class can display either text or a picture, or both. JLabel aligns the label and label contents displayed by it using horizontal and vertical alignments, just as other Swing classes. The alignments allow the programmer to decide where the label's contents will be shown on the label's display area.

The JLabel class object is a component for inserting text into a container. It's used to show a single line of text that can only be read. An application can update the text, but a user cannot edit it directly. It is a descendant of the JComponent class.

JLabel class declaration

Public class JLabel extends JComponent implements SwingConstants, Accessible 

Constructors of JLabel

The JLabel class in Java provides multiple constructors that can be used to generate labels with various properties.

●      JLabel (): This function generates a blank label with no text. This instance of the class generates a label without an image and a title consisting of an empty string or text. The text can be changed at any moment.

●      JLabel (Icon Picture): This function produces a label containing only the icon or image given. You can use the icon or picture file from your own file system.

●      JLabel (String Text): While declaring our function ,this instance creates a label with a specific text. We additionally have the following constructors that can be used in addition to the fundamental constructors listed above.

●      JLabel (Icon Image, int horizontalAlignment): This function instance is used to make a horizontally aligned picture or icon from a given image or icon.

●      JLabel(String text, int horizontalAlignment): This function  instance is used to build a text with horizontal alignment that is supplied.

●      JLabel (String text, Icon icon, int horizontalAlignment): This function instance is used to produce an image or icon, as well as text and a 'horizontal' alignment.

Example

Import javax.swing.*; 

Class LabelExample 

{ 

Public static void main(String args[])

    { 

    JFrame f= new JFrame("Label Example"); 

    JLabel l1,l2; 

    l1=new JLabel("First Label."); 

    l1.setBounds(50,50, 100,30); 

    l2=new JLabel("Second Label."); 

    l2.setBounds(50,100, 100,30); 

    f.add(l1); f.add(l2); 

    f.setSize(300,300); 

    f.setLayout(null); 

    f.setVisible(true); 

    } 

    } 

Output

Q15) Explain JList?

A15) A scrollable list of elements is rendered using the JList component. A user can choose one or more values from the list. The developer defines this select behavior in the code.

A list of text items is represented by the JList class object. The list of text items can be configured such that the user can select one or more items. It is a descendant of the JComponent class.

JList class declaration

Public class JList extends JComponent implements Scrollable, Accessible 

Constructor

●      JList(): Creates a JList with a read-only model that is empty.

●      JList(ary[] listData): The elements in the specified array are shown in a JList.

●      JList(ListModel<ary> dataModel): Creates a JList with elements from the non-null model supplied.

Methods

●      Void addListSelectionListener(ListSelectionListener listener): It's used to add a listener to the list who will be notified whenever the option changes.

●      int getSelectedIndex(): It's used to find the smallest cell index in a selection.

●      ListModel getModel(): It's used to get the data model that holds the list of items that the JList component displays.

●      void setListData(Object[] listData): It's used to turn an array of objects into a read-only ListModel.

Example

Import javax.swing.*; 

Public class ListExample 

{ 

     ListExample(){ 

        JFrame f= new JFrame(); 

        DefaultListModel<String> l1 = new DefaultListModel<>(); 

          l1.addElement("Item1"); 

          l1.addElement("Item2"); 

          l1.addElement("Item3"); 

          l1.addElement("Item4"); 

          JList<String> list = new JList<>(l1); 

          list.setBounds(100,100, 75,75); 

          f.add(list); 

          f.setSize(400,400); 

          f.setLayout(null); 

          f.setVisible(true); 

     } 

Public static void main(String args[]) 

    { 

   new ListExample(); 

    }

} 

Output

Q16) Write about JMenuBar?

A16) JMenuBar is a class that displays a menubar on a window or frame. It could have multiple menus.

The Java Swing package includes JMenuBar, JMenu, and JMenuItems. JMenuBar is a menu bar implementation. When one or more JMenu objects are chosen in the JMenuBar, a popup with one or more JMenuItems appears.

JMenu is a class that depicts a menu. It has multiple JMenuItem Objects in it. It could also include JMenu Objects (or submenu).

JMenuBar class declaration

Public class JMenuBar extends JComponent implements MenuElement, Accessible 

Constructor

JMenuBar() - Creates a new menu bar.

Methods Inherited

This class inherits methods from the following classes −

●      javax.swing.JComponent

●      java.awt.Container

●      java.awt.Component

●      java.lang.Object

Example

Import java.awt.*;

Import java.awt.event.*;

Public class SwingMenuDemo {

   private JFrame mainFrame;

   private JLabel headerLabel;

   private JLabel statusLabel;

   private JPanel controlPanel;

   public SwingMenuDemo(){

      prepareGUI();

   }

   public static void main(String[] args){

      SwingMenuDemo  swingMenuDemo = new SwingMenuDemo();    

      swingMenuDemo.showMenuDemo();

   }

   private void prepareGUI(){

      mainFrame = new JFrame("Java SWING Examples");

      mainFrame.setSize(400,400);

      mainFrame.setLayout(new GridLayout(3, 1));

      headerLabel = new JLabel("",JLabel.CENTER );

      statusLabel = new JLabel("",JLabel.CENTER);       

      statusLabel.setSize(350,100);

      mainFrame.addWindowListener(new WindowAdapter() {

         public void windowClosing(WindowEvent windowEvent){

            System.exit(0);

         }       

      });   

      controlPanel = new JPanel();

      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);

      mainFrame.add(controlPanel);

      mainFrame.add(statusLabel);

      mainFrame.setVisible(true); 

   }

   private void showMenuDemo(){

      //create a menu bar

      final JMenuBar menuBar = new JMenuBar();

      //create menus

      JMenu fileMenu = new JMenu("File");

      JMenu editMenu = new JMenu("Edit");

      final JMenu aboutMenu = new JMenu("About");

      final JMenu linkMenu = new JMenu("Links");

      //create menu items

      JMenuItem newMenuItem = new JMenuItem("New");

      newMenuItem.setMnemonic(KeyEvent.VK_N);

      newMenuItem.setActionCommand("New");

      JMenuItem openMenuItem = new JMenuItem("Open");

      openMenuItem.setActionCommand("Open");

      JMenuItem saveMenuItem = new JMenuItem("Save");

      saveMenuItem.setActionCommand("Save");

      JMenuItem exitMenuItem = new JMenuItem("Exit");

      exitMenuItem.setActionCommand("Exit");

      JMenuItem cutMenuItem = new JMenuItem("Cut");

      cutMenuItem.setActionCommand("Cut");

      JMenuItem copyMenuItem = new JMenuItem("Copy");

      copyMenuItem.setActionCommand("Copy");

      JMenuItem pasteMenuItem = new JMenuItem("Paste");

      pasteMenuItem.setActionCommand("Paste");

      MenuItemListener menuItemListener = new MenuItemListener();

      newMenuItem.addActionListener(menuItemListener);

      openMenuItem.addActionListener(menuItemListener);

      saveMenuItem.addActionListener(menuItemListener);

      exitMenuItem.addActionListener(menuItemListener);

      cutMenuItem.addActionListener(menuItemListener);

      copyMenuItem.addActionListener(menuItemListener);

      pasteMenuItem.addActionListener(menuItemListener);

      final JCheckBoxMenuItem showWindowMenu = new JCheckBoxMenuItem("Show About", true);

      showWindowMenu.addItemListener(new ItemListener() {

         public void itemStateChanged(ItemEvent e) {

            if(showWindowMenu.getState()){

               menuBar.add(aboutMenu);

            } else {

               menuBar.remove(aboutMenu);

            }

         }

      });

      final JRadioButtonMenuItem showLinksMenu = new JRadioButtonMenuItem(

         "Show Links", true);

      showLinksMenu.addItemListener(new ItemListener() {

         public void itemStateChanged(ItemEvent e) {

            if(menuBar.getMenu(3)!= null){

               menuBar.remove(linkMenu);

               mainFrame.repaint();

            } else {                  

               menuBar.add(linkMenu);

               mainFrame.repaint();

            }

         }

      });

      //add menu items to menus

      fileMenu.add(newMenuItem);

      fileMenu.add(openMenuItem);

      fileMenu.add(saveMenuItem);

      fileMenu.addSeparator();

      fileMenu.add(showWindowMenu);

      fileMenu.addSeparator();

      fileMenu.add(showLinksMenu);      

      fileMenu.addSeparator();

      fileMenu.add(exitMenuItem);       

      editMenu.add(cutMenuItem);

      editMenu.add(copyMenuItem);

      editMenu.add(pasteMenuItem);

      //add menu to menubar

      menuBar.add(fileMenu);

      menuBar.add(editMenu);

      menuBar.add(aboutMenu);      

      menuBar.add(linkMenu);

      //add menubar to the frame

      mainFrame.setJMenuBar(menuBar);

      mainFrame.setVisible(true);    

   }

   class MenuItemListener implements ActionListener {

      public void actionPerformed(ActionEvent e) {           

         statusLabel.setText(e.getActionCommand() + " JMenuItem clicked.");

      }   

   }

}

Output

Q17) Write JTabbedPane?

A17) By clicking on a tab with a particular title or icon, the JTabbedPane class is used to switch between a group of components. It is a descendant of the JComponent class.

JTabbedPane class declaration

Public class JTabbedPane extends JComponent implements Serializable, Accessible, SwingConst

Constructor

●      JTabbedPane() : Creates an empty TabbedPane with JTabbedPane's default tab placement. Top.

●      JTabbedPane(int tabPlacement) : Creates an empty TabbedPane with the tab placement you choose.

●      JTabbedPane(int tabPlacement, int tabLayoutPolicy) : Creates an empty TabbedPane with the tab placement and policy supplied.

Example

Import javax.swing.*; 

Public class TabbedPaneExample { 

JFrame f; 

TabbedPaneExample(){ 

    f=new JFrame(); 

    JTextArea ta=new JTextArea(200,200); 

    JPanel p1=new JPanel(); 

    p1.add(ta); 

    JPanel p2=new JPanel(); 

    JPanel p3=new JPanel(); 

    JTabbedPane tp=new JTabbedPane(); 

    tp.setBounds(50,50,200,200); 

    tp.add("main",p1); 

    tp.add("visit",p2); 

    tp.add("help",p3);   

    f.add(tp); 

    f.setSize(400,400); 

    f.setLayout(null); 

    f.setVisible(true); 

} 

Public static void main(String[] args) { 

    new TabbedPaneExample(); 

}} 

Output

Q18) Explain event handling?

A18) The mechanism that manages the event and chooses what should happen if it occurs is known as event handling. An event handler is a piece of code that is run when an event happens in this mechanism.

The events are handled by Java using the Delegation Event Model. The standard mechanism for generating and handling events is defined by this model.

The following are the essential players in the Delegation Event Model.

Source − The source of the event is an object on which it occurs. The source is in charge of informing the handler about the event that occurred. Classes for the source object are provided by Java.

Listener − It's sometimes referred to as an event handler. The listener is in charge of coming up with a reaction to an occurrence. The listener is also an object from the standpoint of Java implementation. The listener sits and waits for an event to occur. The listener processes the event after it is received and then returns.

The advantage of this method is that the user interface logic is kept separate from the event generation logic. The user interface element has the ability to outsource event processing to another piece of code.

The listener must be registered with the source object in this model in order for the listener to receive event notifications. This is a cost-effective method of handling the event because only those listeners who want to receive them are notified.

Steps Involved in Event Handling

●      Step 1: The user presses the button, which triggers the event.

●      Step 2: The concerned event class object is automatically constructed, and information about the source and the event is provided within the same object.

●      Step 3: The event object is passed to the registered listener class's method.

●      Step 4: The method is called and executed.

Example

SwingControlDemo.java

Package com.tutorialspoint.gui;

Import java.awt.*;

Import java.awt.event.*;

Import javax.swing.*;

Public class SwingControlDemo {

   private JFrame mainFrame;

   private JLabel headerLabel;

   private JLabel statusLabel;

   private JPanel controlPanel;

   public SwingControlDemo(){

      prepareGUI();

   }

   public static void main(String[] args){

      SwingControlDemo swingControlDemo = new SwingControlDemo(); 

      swingControlDemo.showEventDemo();      

   }

   private void prepareGUI(){

      mainFrame = new JFrame("Java SWING Examples");

      mainFrame.setSize(400,400);

      mainFrame.setLayout(new GridLayout(3, 1));

      headerLabel = new JLabel("",JLabel.CENTER );

      statusLabel = new JLabel("",JLabel.CENTER);       

      statusLabel.setSize(350,100);

      mainFrame.addWindowListener(new WindowAdapter() {

         public void windowClosing(WindowEvent windowEvent){

            System.exit(0);

         }       

      });   

      controlPanel = new JPanel();

      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);

      mainFrame.add(controlPanel);

      mainFrame.add(statusLabel);

      mainFrame.setVisible(true); 

   }

   private void showEventDemo(){

      headerLabel.setText("Control in action: Button");

      JButton okButton = new JButton("OK");

      JButton submitButton = new JButton("Submit");

      JButton cancelButton = new JButton("Cancel");

      okButton.setActionCommand("OK");

      submitButton.setActionCommand("Submit");

      cancelButton.setActionCommand("Cancel");

      okButton.addActionListener(new ButtonClickListener());

      submitButton.addActionListener(new ButtonClickListener());

      cancelButton.addActionListener(new ButtonClickListener());

      controlPanel.add(okButton);

      controlPanel.add(submitButton);

      controlPanel.add(cancelButton);      

      mainFrame.setVisible(true); 

   }

   private class ButtonClickListener implements ActionListener{

      public void actionPerformed(ActionEvent e) {

         String command = e.getActionCommand(); 

         if( command.equals( "OK" ))  {

            statusLabel.setText("Ok Button clicked.");

         } else if( command.equals( "Submit" ) )  {

            statusLabel.setText("Submit Button clicked.");

         } else {

            statusLabel.setText("Cancel Button clicked.");

         } 

      }

   }

}

Output

Q19) Describe layout manager?

A19) LayoutManagers are used to organize components in a specific way. The Java LayoutManagers help us control the size and positioning of components in GUI forms. The interface LayoutManager is implemented by all kinds of layout managers. The layout managers are represented by the following classes:

1. Java.awt.BorderLayout
2. Java.awt.FlowLayout
3. Java.awt.GridLayout
4. Java.awt.CardLayout
5. Java.awt.GridBagLayout
6. Javax.swing.BoxLayout
7. Javax.swing.GroupLayout
8. Javax.swing.ScrollPaneLayout
9. Javax.swing.SpringLayout etc.

BorderLayout

The BorderLayout is used to divide the components into five different regions: north, south, east, west, and middle. Only one component can be present in each region (area). That is the standard frame or window arrangement. For each field, the BorderLayout provides five constants:

1. Public static final int NORTH
2. Public static final int SOUTH
3. Public static final int EAST
4. Public static final int WEST
5. Public static final int CENTER

Fig: Example of border layout

FlowLayout

The FlowLayout is used to line up the components one after another in a line (in a flow). It is the applet or panel's default layout.

Field of flowlayout class

1. Public static final int LEFT
2. Public static final int RIGHT
3. Public static final int CENTER
4. Public static final int LEADING
5. Public static final int TRAILING

Fig: Example of flowlayout

GridLayout

The GridLayout is used to make a rectangular grid out of the components. Each rectangle displays a single part.

Fig: Example of grid layout

Constructor of gridlayout class

1. GridLayout(): creates a grid layout in which each part in a row has one column.
2. GridLayout(int rows, int columns): creates a grid layout with the defined rows and columns, but no gaps between them.
3. GridLayout(int rows, int columns, int hgap, int vgap): creates a grid with the specified rows and columns, as well as the specified horizontal and vertical gaps.

CardLayout

The CardLayout class organizes the components such that only one is available at any given time. It is called CardLayout because it treats each part as a card.

Constructors of CardLayout class

1. CardLayout(): creates a card layout with no vertical or horizontal gaps.
2. CardLayout(int hgap, int vgap): creates a card layout with the horizontal and vertical gaps specified.

Fig: Example of cardlayout

GridbagLayout

Components may be aligned vertically, horizontally, or along their baseline using the Java GridBagLayout class.

It's possible that the components aren't all the same size. A dynamic, rectangular grid of cells is maintained by each GridBagLayout object. Each portion has a display area that consists of one or more cells. GridBagConstraints is associated with each component. We use the constraints object to organize the display area of the part on the grid. In order to decide component size, the GridBagLayout manages each component's minimum and desired sizes.

Fig: Example of Gridbaglayout

BoxLayout

The BoxLayout is used to vertically or horizontally organize the elements. BoxLayout offers four constants for this reason. The following are the details:

1. Public static final int X_AXIS
2. Public static final int Y_AXIS
3. Public static final int LINE_AXIS
4. Public static final int PAGE_AXIS

Constructor

●      BoxLayout(Container c, int axis): creates a box arrangement with the specified axis that arranges the components.

Fig: Example of boxlayout

Q20) What is JMenu?

A20) JMenu, JMenuBar, and JMenuItems are Java Swing components. JMenuBar is a menu bar implementation. At least one JMenu object is present in the JMenuBar. When these items are selected, a popup appears that shows at least one JMenuItems. It essentially communicates with a menu. It has a couple JMenuItem Objects in it. It could also include JMenu Objects (or submenu). The Menu class corresponds to the drawdown menu component of a menu bar. The JMenuItem class represents a real menu item. JMenuItem or one of its subclasses should be used for anything in a menu.

The JMenu class's object is a pull-down menu component that appears in the menu bar. It is a descendant of the JMenuItem class.

JMenu declaration

Public class JMenu extends JMenuItem implements MenuElement, Accessible

Constructor

●      JMenu (): It will build a new Menu without any content.

●      JMenu (String name): Creates a new Menu with the name you specify.

●      JMenu (String name, Boolean b): Creates a new Menu with a predefined name and decides whether it is a remove menu or not using Boolean esteem. Open and drag a detach menu away from its parent menu bar or menu.

Example

Import java.awt.*;

Import javax.swing.*;

Import java.awt. Event. *;

Public class menu extends JFrame {

// Menu Bar declaration

Static JMenuBar xb;

// JMenu declaration

Static JMenu x;

// Menu items

Static JMenuItem x1, x2, x3;

// frame creation declaration

Static JFrame y;

Public static void main()

{

// frame creation using new keyword

y = new JFrame ("Menu Demo");

// menu bar creation using new keyword

Mb = new JMenuBar ();

// menu creation using new keyword

z = new JMenu("Menu");

// menu item creation using new keyword

x1= new JMenuItem("MenuItem1");

x2= new JMenuItem("MenuItem2");

x2= new JMenuItem("MenuItem3");

// add menu items to menu

x.add(x1);

x.add(x2);

x.add(x3);

// add menu to menu bar

Xb.add(z);

// add menubar to frame

y.setJMenuBar(xb);

// set the size of the frame

y.setSize(500, 500);

y.setVisible(true);

}

}

Output