Sometimes you may want to know the precise information about the font such as height, ascent, decent and leading etc. For example, if you want to display string in the center of the panel.

This information is made available using the FontMetrics class. To use the FontMetrics class in Java, you need to understand the following terms that are used in FontMetrics class whichare the same as used by typesetters.

• Baseline: It refers to the line on which the bottom of the most characters occurs.

• Ascent: It is the distance from the baseline to the top of an ascender which is the upper part of a letter like b or k or an uppercase letter.

• Descent: It is the distance from the baseline to a descender which is the lower part of letters such as y or p.

• Leading: It is spacing between the descent of one line of text and the ascent of the next line of text.

• Height: It is the sum (in pixels) of the ascent, descent and leading values.

import java.awt.*; 
 class FontMetricsExample extends Frame 
 { 
      TextArea txtData; 
      String str="" ; 
      FontMetricsExample() 
     { 
            Font myfont = new Font("Serif",Font.BOLD,12); 
            FontMetrics metrics = getFontMetrics(myfont); 
            str=str+ "Ascent of the Font = " + metrics.getAscent(); 
            str = str + "\n Maximum Ascent of the Font = " + metrics.getMaxAscent(); 
            str = str + "\n Descent of the Font = " + metrics.getDescent(); 
            str = str + "\n Maximum Desent of the Font = " + metrics.getMaxDescent(); 
            str = str + "\n Leading of the Font = " + metrics.getLeading(); 
            str = str + "\n Height of the Font = " + metrics.getHeight(); 
            txtData=new TextArea(10,15); 
            txtData.setText(str); 
            add(txtData); 
      } 
 } 
  class FontMetricsJavaExample 
  { 
         public static void main(String [] args) 
        { 
              FontMetricsExample frame = new FontMetricsExample(); 
              frame.setTitle("Font Metrics in Java Example"); 
              frame.setSize(300,1500); 
              frame.setVisible(true); 
        } 
  } 
 

In order to set a different font, Java provides the Font class contained in java. awt package. You can create the Font object using the following constructor.

public Font(String name, int style, int size);

Here, the parameter namecorresponds to the logical font name. The logical font is one of the five font families supported by Java runtime environment. These include Serif, SansSerif,Monospaced,Dialog and DialogInput. The parameter style represents the Font shape which can take the values Font.Plain(0), Font.Bold(l), Font.Italic(2) and Font.Bold +Font. Italic (3). The parameter size specify the font size which can be any positive integer. The font size is measured in points. A point in 1/72 of an inch.

Font Useful Interface

import java.awt.*; 
 class FontExample extends Frame 
 { 
    FontExample() 
    { 
         setLayout(new FlowLayout()); 
         Font f = new Font("Serif",Font.BOLD,12); 
         Label lblUserid = new Label("Userid"); 
         lblUserid.setFont(f); 
         TextField txtUserid = new TextField("Mr Thakur",15); 
         txtUserid.setFont(f); 
         Button btnOK = new Button("OK"); 
         add(lblUserid); add(txtUserid); 
     } 
 } 
  class FontJavaExample 
  { 
        public static void main(String args[]) 
       { 
            FontExample frame = new FontExample(); 
            frame.setTitle("Font Usage in Java Example"); 
            frame.setSize(250,150); 
            frame.setVisible(true); 
       } 
 } 
 

However, if you want to change the color of the text or GUI components, Java provides the Color class contained in java.awt.package. Every color is made up of red, green and blue components, each represented by an unsigned byte value that describes its intensity. You can specify the intensity of each color to be a value ranging from 0 to 255 where 0 represents the darkest shade and 255 represents the lightest shade. This is known as RGB model.

In order to create a Color object use the following constructors.

• public Color (int r, int g, int b) : The three parameters r, g, b correspond to the intensities of red, green and blue components of the Color respectively. The values that these parameters can hold range from 0 to 255. If you specify a value beyond this range then an IllegalArgumentException exception will be raised. For example: The statement.

Color c = newColor (255,200,0);

creates a Color object that represent the color orange. The first RGB component (i.e. 255) represents the amount of red, the second (i.e. 200) represents the amount of green and the third(i.e. 0) represents the amount of blue. Together these components form the orange color.

• public Color(float r, float g, float b): The three parameters r,g,b correspond to the intensities of red, green and blue components that can be represented by floating-point values in the range 0.0.to 1.0.

Color Interface

import java.awt.*; 
 class ColorExample extends Frame 
 { 
    ColorExample() 
    { 
           Color frameColor = new Color(0,255,255); 
           setLayout(new FlowLayout()); 
           setBackground(frameColor); 
           Button btnCancel = new Button("Cancel"); 
           btnCancel.setBackground(Color.BLACK); 
           btnCancel.setForeground(Color.WHITE); 
           add(btnCancel); 
    
     } 
 } 
  class ColorJavaExample 
 { 
           public static void main(String args[]) 
        { 
               ColorExample frame = new ColorExample(); 
               frame.setTitle("Color in Java Example"); 
               frame.setSize(400,150); 
               frame.setVisible(true); 
         } 
 } 
 

A popupmenu is a small window that pops up and displays a list of choices such as Cut, Copy, Paste, Select All etc. This menu is invisible until the user makes a platform specific mouse action such as pressing the right mouse button over a popup enabled component. The popup menu then appears under the cursor.

In order to create a pop up menu, java .awt .PopupMenu class is used. It is a subclass of Menu and is used very much like a Menu. It provides the following two constructors

• PopupMenu () – Creates an empty popup menu.

• PopupMenu (String title) – Creates an empty pop up menu with the as the title of the popup menu.

As expected, the AWT provides fairly complete support for creating applications using the menu bar (menu bar), drop down menus (pull-down menus) and  independent menu (pop-up menus) through set of classes briefly described following:

import java.awt.*; 
 class PopupMenuExample extends Frame 
 { 
      PopupMenu popupMenu; 
      public PopupMenuExample() 
     { 
            setLayout(new FlowLayout()); 
            popupMenu = new PopupMenu(); 
            popupMenu.add(new MenuItem("Cut")); 
            popupMenu.addSeparator(); 
            popupMenu.add(new MenuItem("Cut")); 
            popupMenu.addSeparator(); 
            popupMenu.add(new MenuItem("paste")); 
            add(popupMenu);    
            setTitle("PopupMenu in Java Example"); 
            setSize(300,120); 
            setVisible(true); 
            popupMenu.show(this,100,100); 
     } 
 } 
  class PopupMenuJavaExample 
  { 
         public static void main(String[] args) 
        { 
             PopupMenuExample frame = new PopupMenuExample(); 
        } 
  } 
 

Creating a menu bar is straight forward. You have to simply create an instance of Java.awt.MenuBar which is a container for menus. It has only one constructor which is the default constructor as follows,

public MenuBar ()

Once you create the menu bar, you can add it to a frame with the setMenuBar () method of Frame class. One should remember that each application has only one menu.

The following statements create a menu bar and add it to the top of the frame.

Menubar menuBar = new MenuBar();

setMenubar(menuBar);

These statements are part of the class that extends Frame.

Initially the menubar is empty and you need to add menus before using it. Each menu is represented by an instance of class Menu. In order to create a Menu instance, you have to use the following constructor.

public Menu(String str)

where str represents the label for the menu. For example: In order to create a File menu, use the following statement

Menu menuFile = new Menu(“File”);

Similarly to create Edit and View menu, use the statements

Menu menuEdit = new Menu(“Edit”);

Menu menuView = new Menu (“View”);

Once the Menu objects are created, we need to add them to the menu bar. For this, you have to use

the add () method of the MenuBar class whose syntax is as follows,

Menu add (Menu menu)

where menu is Menu instance that is added to the menu bar. This method returns a reference to the menu. By default, consecutively added menus are positioned in the menu bar from left to right. This makes the first menu added the leftmost menu and the last menu added the rightmost menu. If you want to add a menu at a specific location, then use the following version of add ()method inherited from the Container class.

Component add (Component menu, int index)

where menu is added to the menu bar at the specified index. Indexing begins at 0, with 0 being the leftmost menu. For example: In order to add menu instance menuFile to the menuBar use the following statement,

menuBar.add(menuFile);

Similarly, add other Menu instances menuEdit,menuView using the following statements,

menuBar.add(menuEdit);

menuBar.add(menuView);

import java.awt.*; 
 class MenuExample extends Frame 
 { 
        MenuExample() 
       { 
            MenuBar menuBar = new MenuBar(); 
            setMenuBar(menuBar); 
            Menu menuFile = new Menu("File"); 
            Menu menuEdit = new Menu("Edit"); 
            Menu menuView = new Menu("View"); 
            menuBar.add(menuFile); 
            menuBar.add(menuEdit); 
            menuBar.add(menuView); 
            MenuItem itemOpen = new MenuItem("Open"); 
            MenuItem itemSave = new MenuItem("Save"); 
            MenuItem itemExit = new MenuItem("Exit"); 
            menuFile.add(itemOpen); 
            menuFile.add(itemSave); 
            menuFile.add(itemExit); 
            MenuItem itemcopy = new MenuItem("Copy"); 
            menuEdit.add(itemcopy); 
      } 
 } 
   class MenuJavaExample 
   { 
           public static void main(String args[]) 
          { 
               MenuExample frame = new MenuExample(); 
               frame.setTitle("Menu in Java Example"); 
               frame.setSize(350,250); 
               frame.setResizable(false); 
               frame.setVisible(true); 
          } 
   } 
 

The java.awt.GridBagLayout layout manager is the most powerful and flexible of all the predefined layout managers but more complicated to use. Unlike GridLayout where the component are arranged in a rectangular grid and each component in the container is forced to be the same size, in GridBagLayout, components are also arranged in rectangular grid but can have different sizes and can occupy multiple rows or columns.

In order to create GridBagLayout, we first instantiate the GridBagLayout class by using its only no-arg constructor

public GridLayout();

and defining it as the current layout manager. The following statements accomplish this task;

GridBagLayout layout = new GridBagLayout();

setLayout(layout);

A GridBagLayout layout manager requires a lot of information to know where to put a component in a container. A helper class called GridBagConstraints provides all this information. It specifies constraints on how to position a component, how to distribute the component and how to resize and align them. Each component in a GridBagLayout has its own set of constraints, so you have to associate an object of type GridBagConstraints with each component before adding component to the container.

Instance variables to manipulate the GridBagLayout object Constraints are:

import java.awt.*; 
 class GridBagLayoutExample extends Frame 
 { 
      GridBagLayoutExample() 
      {   
          Label lblName = new Label("Name"); 
          TextField txtName =new TextField(10); 
          Label lblcomments = new Label("Comments"); 
          TextArea TAreaComments=new TextArea(6,15); 
          Button btnSubmit = new Button("Submit"); 
          setLayout(new GridBagLayout()); 
          GridBagConstraints gc =new GridBagConstraints(); 
          add(lblName,gc,0,0,1,1,0,0); 
          add(txtName,gc,1,0,1,1,0,20); 
          add(lblcomments,gc,0,1,1,1,0,0); 
          add(TAreaComments,gc,1,1,1,1,0,60); 
          add(btnSubmit,gc,0,2,2,1,0,20); 
      } 
     void add(Component comp,GridBagConstraints gc,int x,int y,int w,int h,int wx,int wy) 
      {    
          gc.gridx = x; 
          gc.gridy = y; 
          gc.gridwidth = w; 
          gc.gridheight= h; 
          gc.weightx = wx; 
          gc.weighty = wy; 
          add(comp,gc); 
      } 
 } 
    class GridBagLayoutJavaExample 
   { 
         public static void main(String args[]) 
        { 
              GridBagLayoutExample frame = new GridBagLayoutExample(); 
              frame.setTitle("GridBagLayout in Java Example"); 
              frame.setSize(300,200); 
              frame.setVisible(true); 
        } 
   } 
 

The java.awt.CardLayout layout manager is significantly different from the other layout managers. Unlike other layout managers, that display all the components within the container at once, a CardLayout layout manager displays only one component at a time (The component could be a component or another container).

Each component in a container with this layout fills the entire container. The name cardlayout evolves from a stack of cards where one card is piled upon another and only one of them is shown. In this layout, the first component that you add to the container will be at the top of stack and therefore visible and the last one will be at the bottom.

Java.awt.CardLayout the class selected the following constructors and methods: 

import java.awt.*;   
 import java.awt.event.*; 
 class CardLayoutExample extends Frame implements ActionListener 
 { 
      CardLayout card = new CardLayout(20,20); 
      CardLayoutExample() 
      { 
          setLayout(card); 
          Button Btnfirst = new Button("first "); 
          Button BtnSecond = new Button ("Second"); 
          Button BtnThird = new Button("Third"); 
          add(Btnfirst,"Card1"); 
          add(BtnSecond,"Card2"); 
          add(BtnThird,"Card3"); 
          Btnfirst.addActionListener(this); 
          BtnSecond.addActionListener (this); 
          BtnThird.addActionListener(this); 
      } 
      public void actionPerformed(ActionEvent e) 
      { 
        card.next(this); 
      } 
 } 
    class CardLayoutJavaExample 
    { 
         public static void main(String args[]) 
        { 
             CardLayoutExample frame = new CardLayoutExample(); 
             frame.setTitle("CardLayout in Java Example"); 
             frame.setSize(220,150); 
             frame.setResizable(false); 
             frame.setVisible(true); 
        } 
    } 
 

The GridLayout layout manager divides the container into a rectangular grid so that component can be placed in rows and column. The intersection of each row and column is known as a cell. The components are laid out in cells and each cell has the same size, components are added to a GridLayout starting at the top left cell of the grid and continuing to the right until the row is full. The process continues left to right on the next row of the grid and so on.

The java.awt.GridLayout class contain the following constructors and methods that can use to customize this manager:

import java.awt.*; 
 class GridLayoutExample extends Frame 
 { 
     GridLayoutExample() 
     { 
          Button[] button =new Button[12]; 
          setLayout(new  GridLayout(4,3)); 
          for(int i=0; i<button.length;i++) 
             { 
                button[i]=new Button("Button "+(i+i)); 
                add(button[i]); 
             } 
      } 
 } 
   class GridLayoutJavaExample 
   { 
       public static void main(String args[]) 
       { 
           GridLayoutExample frame = new GridLayoutExample(); 
           frame.setTitle("GridLayout in Java Example"); 
           frame.setSize(400,150); 
           frame.setVisible(true); 
       } 
   } 
 

The BorderLayout layout manager divides the container into five regions that are named geographically: Top (north), lower (south), left (west), right (east) and central (center). North corresponds to the top of the container. You can add only one component per region to a container controlled by a BorderLayout layout manager. However, this limitation can be overcome by adding a container with multiple components (such as Panel). Components laid out by this layout manager normally do not get to have their preferred size.

The components added to the NORTH or SOUTH regions will get its width equal to the width of the container while maintaining their preferred height. The components added to the EAST or WEST regions will get its height equal to the height of the container minus any components in NORTH or SOUTH while maintaining their preferred width. The component that are added to the CENTER will fill up the rest of the space in horizontal and vertical dimensions. BorderLayout is the default layout manager for a JApplet, JFrame, JDialog and JWindow.

The java.awt.BorderLayout class contain the following constructors and methods that can use to customize this manager:

import java.awt.*; 
 class BorderLayoutExample extends Frame 
 { 
     BorderLayoutExample() 
     { 
          setLayout(new BorderLayout()); 
          add(new Button("NORTH"),BorderLayout.NORTH); 
          add(new Button("SOUTH"),BorderLayout.SOUTH); 
          add(new Button("EAST"),BorderLayout.EAST); 
          add(new Button("WEST"),BorderLayout.WEST); 
          add(new Button("CENTER"),BorderLayout.CENTER); 
      } 
 } 
    class BorderLayoutJavaExample 
    { 
        public static void main(String args[]) 
       { 
           BorderLayoutExample frame = new BorderLayoutExample(); 
           frame.setTitle("BorderLayout in Java Example"); 
           frame.setSize(400,150); 
           frame.setVisible(true); 
       } 
   } 
 

The FlowLayout is one the most popular and simplest layout manager. It places components in a container from left to right in the order in which they were added to the container. When one row is filled, layout advances to the next row. It is analogous to lines of text in a paragraph. Components managed by a FlowLayout are always set to their preferred size (both width and height) regardless of the size of the parent container. Whenever the container is resized then the components in the container are also adjusted from the top-left comer. The FlowLayout is the default layout manager for a Panel, Applet and JPanel.

The java.awt.FlowLayout class contain the following constructors and methods:

Also has the constant–FlowLayout.LEFT, and FlowLayout.CENTER FlowLayout.RIGHT who can be used to specify or determine the alignment of this layout manager.

import java.awt.*; 
 class FlowLayoutExample extends Frame 
 { 
      FlowLayoutExample() 
      { 
          Button[] button =new Button[10]; 
          setLayout(new FlowLayout()); 
          for(int i=0;i<button.length;i++) 
              { 
                   button[i]=new Button("Button "+(i+1)); 
                   add(button[i]); 
              } 
        } 
 } 
   class FlowLayoutJavaExample 
   { 
        public static void main(String args[]) 
       { 
              FlowLayoutExample frame = new FlowLayoutExample(); 
              frame.setTitle("FlowLayout in Java Example"); 
              frame.setSize(400,150); 
              frame.setVisible(true); 
        } 
   } 
 

How does Java come to know where to place the component into the container. One possible way is to tell it manually. By manually, we mean that you have to specify the size and position of each component yourself.

import java.awt.*; 
 class setLayoutExample extends Frame 
 { 
       setLayoutExample() 
       { 
             setLayout(null); 
             Label lblRollno = new Label("Rollno : "); 
             lblRollno.setSize(50,120); 
             TextField txtRollno = new TextField(15); 
             txtRollno.setSize(50,120); 
             add(lblRollno); add(txtRollno);    
        } 
 } 
    class setLayoutJavaExample 
   { 
         public static void main(String args[]) 
        { 
            setLayoutExample frame = new setLayoutExample(); 
            frame.setTitle("Manually setLayout in Java Example"); 
            frame.setSize(250,150); 
            frame.setVisible(true); 
       } 
   } 
 

The java.awt.Panel or Panel is a container that is designed to group a set of components, including other panels. It is visually represented as window that does not contain a title bar, menu bar or border. Panels are represented by objects created from Panel class by calling the constructor. The java.awt.Panel class has two constructors:

java.awt.Panel class shares the following methods with their ancestor class java.awt.Container.

After the panel has been created, other components can be added to Panel object by calling its add (Component c) method inherited from the Container class. The following code fragment demonstrates creating a panel and adding two buttons to it.

Panel p = new Panel();

p. add (new Button (“OK”);

p.add(new Button(“Cancel”);

Using panels, you can design complex GUls.

import java.awt.*; 
 class PanelExample extends Frame 
 { 
        Panel panel1,panel2,panel3 ; 
        Label  lblpanel1,lblpanel2,lblpanel3; 
        PanelExample() 
        { 
             setLayout(new FlowLayout()); 
             panel1 = new Panel(); 
             lblpanel1 = new Label("Panel with Gray Background"); 
             panel1.add(lblpanel1); 
             Button bt1 = new Button("1"); 
             panel1.add(bt1); 
             panel1.setBackground(Color.gray); 
             add(panel1); 
             panel2=new Panel(); 
             lblpanel2 = new Label("Panel with Cyan Background"); 
             panel2.add(lblpanel2); 
             Button bt2 = new Button("2"); 
             panel2.add(bt2); 
             panel2.setBackground(Color.cyan); 
             add(panel2); 
        } 
 } 
     class PanelJavaExample 
     { 
          public static void main(String[] args) 
         { 
              PanelExample frame = new PanelExample(); 
              frame.setTitle("Panels in Java Example"); 
              frame.setSize(250,200); 
              frame.pack(); 
              frame.setVisible(true); 
         } 
    } 
 

A scrollbar is a component that allows a user to select any numeric value by dragging a slider within a range defined by a minimum and maximum. A scrollbar may be oriented horizontally or vertically. A scrollbar consists of several individual parts: arrows (the buttons at each end of the scrollbar), a slider box or thumb (scrollable box you slide) and a track (part of the scrollbar you slide the thumb in).

Whenever the user clicks the arrows on either end, the current value of the scrollbar is modified by a unit depending upon direction of the arrows. The slider box indicates the current value of the scrollbar. The user can also click anywhere on the track to move the slider box to jump in that direction by some value larger than 1. It can be formed with the following constructors:

Scrollbar();
Scrollbar(int style);
Scrollbar(int style. int initialvalue, int thumbsize,int min. int max);
The second constructor creates a scroll bar with specified orientation, that is, horizontal or vertical. The third form specifies the initial value and the maximal value along with the thumb size. After initiating the Scroll with the default constructor, the values can be set using the following method:
void setValues(int initial. int thumbsize. int max);
The methods getValue() and setValue() are used to get and set the value of the scroll bar at a particular instant. The unit increment and block increment can be set using the methods:
void setUnitlncrement(int new)
void setBlocklncrement(int new)
The minimum value and the maximum value of the scrollbar can be obtained using getMinimum( ) and getMaximum( ) methods. There are two types of the scrollbarsvertical and horizontal. When creating scrollbars, the constants Scrollbar.VERTICAL and Scrollbar.HORIZONTAL are used. When a block in the scrollbar is adjusted, AdjustmentEvent is generated and hence the AdjustmentListener interface has to be used to handle the scrollbar. Program illustrates the use of scroll bars .

Scrollbar Interface

import java.awt.*; 
 class ScrollBarExample extends Frame 
 { 
      ScrollBarExample() 
      { 
            setLayout(new FlowLayout()); 
            //Horizontal Scrollbar with min value 0,max value 100,initial value 50 and visible amount 10 
            Label lblHor =new Label("Horizontal Scrollbar"); 
            Scrollbar sl = new Scrollbar(Scrollbar.HORIZONTAL,50,10,0,100); 
            //Vertical Scrollbar with min value 0,max value 255,initial value 10 and visible amount 5 
            Label lblver =new Label("Vertical Scrollbar"); 
            Scrollbar s2 = new Scrollbar(Scrollbar.VERTICAL,10,5,0,10); 
            add(lblHor); add(sl); 
            add(lblver); add(s2); 
      } 
 } 
      class ScrollBarJavaExample 
      { 
            public static void main(String args[]) 
           { 
                ScrollBarExample frame = new ScrollBarExample(); 
                frame.setTitle("Scrollbar in Java Example"); 
                frame.setSize(520,200); 
                frame.setVisible(true); 
           } 
      } 
 

The java.awt.List component , known as a listbox or list box,  is similar to the Choice component, except it shows multiple items at a time and user is allowed to select either one or multiple items at a time. When the numbers of items in the list exceed the available space, the scrollbar will be displayed automatically. A list can be created by instantiating a List class.

The types of constructor supported by List control are the following:

List list=new List();
List list=new List(int numberofrows);
Ust list=new List(int numberof rows, boolean multi selection);

The first constructor is tbe default list. The second specifies the number of rows to be visible in the list and the third constructor specifies whether the multiple selections can be made. The methods that are used to add and select an item to the List are the same as those of Choice. Since it supports multiple selections, there are several methods that interact in this control. The two commonly used methods are:
String[] getSelectedltems();
Int[ ] getSelectedlndexes();
There is a method by name getitemCount() to get the number of items in the given list.

 The List Box allows display a list of items with the following characteristics :
( i ) the items can not be edited directly by the user ,
( ii ) A vertical scroll bar automatically appears when the box list contains more items than it can display;
( iii ) can be configured to allow selection of a single item or multiple items, and
( iv ) when you click on an item not selected this shall be selected and vice versa .

This component produces basically two types of events :

java.awt.event.ItemEvent when selecting an item occurs and java.awt.event.ActionEvent when the user double-click a displayed item the list . These events require treatment by different listeners respectively as interfaces : java.awt.event.ItemListener and java.awt.event.ActionListener .
It is recommended not to use up the ActionListener event when the list is operating in multiple-selection mode as this may hinder user interaction .

List Interface

import java.awt.*; 
 class ListExample extends Frame 
 { 
      ListExample() 
      { 
          setLayout(new FlowLayout()); 
          Label lblLanguage = new Label("Choose the Language"); 
          List lstLanguage = new List(3,true); 
          lstLanguage.add("pascal"); 
          lstLanguage.add("fortran"); 
          lstLanguage.add("C"); 
          lstLanguage.add("C++"); 
          lstLanguage.add("java"); 
          add(lblLanguage);   add(lstLanguage); 
       
       } 
 } 
    class ListJavaExample 
    { 
          public static void main(String args[]) 
       { 
             ListExample frame = new ListExample(); 
             frame.setTitle("List in Java Example"); 
             frame.setSize(250,150); 
             frame.setResizable(false); 
             frame.setVisible(true); 
       } 
   } 
 

The Choice component is a combination of textfield and drop down list of items. User can make selection by clicking at an item from the list or by typing into the box. Note that you cannot select multiple items from the list. This component is the best component to use than the check box groups or list because it consumes less space than these components. It can be created by instantiating the Choice class. Choice has only one default constructor, namely the following.

Choice choice = new Choice()

To add items to the choice created in the above statement, the following methods can be used.

choice.addltem(String str);
choice.add(String str);

To get the selected item, the method getSelectedltem is used and the index of the selected item can be obtained using the method getSelectedlndex. Items can also be selected using select(int index) and select(String name) when either the index or the name of the item is known.

Choice Interface

import java.awt.*; 
 class ChoiceExample extends Frame 
 { 
      ChoiceExample() 
      { 
           setLayout(new FlowLayout()); 
           Label lblCourse = new Label("Course"); 
           Label lblweekDay = new Label("Day"); 
           Choice course = new Choice(); 
           course.add("BCA"); 
           course.add("MCA"); 
           course.add("MBA"); 
           String[] day={"Mon","Tue","wed","Thu","fri","Sat","Sun"}; 
           Choice weekDay =new Choice(); 
           for(int i=0;i<day.length; i++) 
               { 
                     weekDay.add(day[i]); 
               }                                   
                    add(lblCourse);    add(course);       
                    add(lblweekDay);  add(weekDay); 
       } 
 } 
   class ChoiceJavaExample 
   { 
        public static void main(String args[]) 
       { 
                ChoiceExample frame = new ChoiceExample(); 
                frame.setTitle("Choice in Java Example"); 
                frame.setSize(250,100); 
                frame.setResizable(false); 
                frame.setVisible(true); 
       } 
  } 
 

A check box group is a set of checkboxes in which one and only one checkbox can be checked at anyone time. Any other previously selected checkbox in the group is unchecked. These checkboxes are sometimes called radio buttons.

To create a check box group, follow the following steps,

1. Creating a CheckboxGroup object using the following constructor.

CheckboxGroup()

For example, the following statement creates a checkbox group named sex.

CheckboxGroup sex = new CheckboxGroup();

2. Create a Checkbox object: Pass a reference to the CheckboxGroup object to the Checkbox constructor. The Checkbox class provides the following two constructors to include a checkbox in acheckbox group.

Checkbox(String str,boolean state,CheckboxGroup cbgroup)

Checkbox(String str,CheckboxGroup cbGroup,boolean state)

Here, str specifies the label of the associated checkbox, state specifies the initial state of the associated check box, cbgroup is the checkbox group for the associated checkbox or null if the checkbox is not the part of a group.

For example, the following statements add two checkboxes labelled Male and Female to the checkbox group sex.

Checkbox(“Male”,true,sex);

Checkbox(“Female”,false,sex);

In Table we have the main methods of java.awt.CheckboxGroup class.

import java.awt.*; 
 class CheckboxExample extends Frame 
 { 
      CheckboxExample() 
      { 
           setLayout(new FlowLayout()); 
           Label lblSex = new Label("Sex"); 
           CheckboxGroup sex = new CheckboxGroup(); 
           Checkbox ChkMale = new Checkbox("Male",true,sex); 
           Checkbox Chkfemale = new Checkbox("Female",false,sex); 
           add(lblSex); 
           add(ChkMale); 
           add(Chkfemale); 
      } 
 } 
   class CheckboxGroupJavaExample 
  { 
       public static void main(String args[]) 
      { 
           CheckboxExample frame = new CheckboxExample(); 
           frame.setTitle("CheckboxGroup Java Example"); 
           frame.setSize(250,100); 
           frame.setResizable(false); 
           frame.setVisible(true); 
      } 
  } 
 

The check box, as it is also known java.awt.Checkbox component is a component used to plot an option which can be connected (on ​​= true) or off (off = false). It is usually used to display a set of options which can be selected independently by the user, or allow multiple selections. These controls also have a label associated with them which describes the option of the checkbox. This control supports many constructors.

Checkbox chbox=new Checkbox();
Checkbox chbox=new Checkbox(String str);
Checkbox chbox=new Checkbox(String str, boolean true);

Given above are three types of constructor for the checkbox. The first form creates the default checkbox. The label for the check box can be set using the setLabel() method. The second constructor creates a checkbox with the specified label. The last one creates a checkbox that can be set as checked or unchecked.
The state of a checkbox may change at any instant of time. Therefore a method called
setState(boolean on) is used to change the state of the checkbox. The method getState() is used to get the state of the checkbox. This method retums a boolean value. Since item state changes, it generates the event called Item Event, which is handled by the Item Listener interface.

 A checkbox component is a labelled or unlabelled square box that contains a checkmark when it is selected and nothing otherwise. Checkboxes are mostly used when you need to choose whether you want an option or not. By convention, any number of checkboxes in a group can be selected. It can be created by instantiating the Checkbox class.

Checkbox object is essentially a bi-state switch that remains in the user-selected (or programmatically set) state. The Checkbox is strictly an on/off component and generally depends on other UI objects (typically labels) to indicate what the two states really mean.

Checkbox Useful Interface

import java.awt.*; 
 class CheckBoxExample extends Frame 
 { 
      CheckBoxExample() 
     { 
         setLayout(new FlowLayout());  
         Label lblHobbies = new Label("HOBBIES"); 
         Checkbox chkSports = new Checkbox("Sports"); 
         Checkbox chkMusic = new Checkbox("Music ",true); 
         Checkbox chkReading = new Checkbox("Reading"); 
         add(lblHobbies); 
         add(chkSports); 
         add(chkMusic); 
         add(chkReading); 
     } 
 } 
    class CheckboxJavaExample 
   { 
          public static void main(String args[]) 
         { 
                 CheckBoxExample frame = new CheckBoxExample(); 
                 frame.setTitle("Checkbox in Java Example"); 
                 frame.setSize(350,100); 
                 frame.setResizable(false); 
                 frame.setVisible(true); 
          } 
   } 
 

Buttons are perhaps the most familiar of all the component types. It is a regular push button that can contain text. It can be created by instantiating the Button class. The text on the face of the button is called button label. The buttons, components encapsulated in java.awt.Button class are as panels labeled with a text that, when activated, can trigger the execution of a routine or sequence of commands. Whenever a push button is clicked, it generates an event and executes the code of the specified listener. A button can be created using the following syntax:

Button button=new Button( );
Button button=newButton(String button name);

Button objects provide the most basic (and most commonly used bi-state controls in the AWT. They are generally labeled with SUBMIT, YES, ACCEPT, NO, or other simple one- or two word messages. Very seldom are AWT Buttons sub classed in a normal application.

A Button is added to a Container object (usually a Panel or a descendant of Panel) and is then said to be contained or owned by the Panel. The event handler for the Panel is normally considered to be responsible for any actions upon the Button.

Button Useful Interface

import java.awt.*; 
 class ButtonExample extends Frame  
 { 
      ButtonExample() 
      { 
          setLayout(new FlowLayout());       
          Button btnOK = new Button("OK"); 
          add(btnOK); 
      } 
 }  
     class ButtonsJavaExample 
    { 
        public static void main(String args[]) 
       {     
            ButtonExample frame = new ButtonExample(); 
            frame.setTitle("Buttons in Java Example"); 
            frame.setSize(250,100); 
            frame.setResizable(false); 
            frame.setVisible(true); 
      }   
    } 
 

The TextArea component is similar to the TextField component except that it allows to display and edit multiple lines of plaintext. The TextArea component has certain number of rows and columns that determines its size. If all the text cannot be displayed in the available space in the component, even then scrollbars are not automatically added. In order to add scrollbars, you must insert it into a Scrollpane.

import java.awt.*; 
 class TextAreaExample extends Frame 
 { 
      TextAreaExample() 
      { 
           setLayout(new FlowLayout()); 
           Label label = new Label("Comment Box"); 
           TextArea txtArea = new TextArea("TextArea",3,15); //TextArea with 3 rows and 15 columms 
           add(label); 
           add(txtArea); 
       } 
 } 
    class TextAreaJavaExample 
    { 
          public static void main(String args[]) 
         { 
                TextAreaExample frame = new TextAreaExample(); 
                frame.setTitle("TextArea in Java Example"); 
                frame.setSize(350,150); 
                frame.setVisible(true); 
         } 
    } 
 

A Textfield is a component used for displaying, inputting and editing a single line of plain text. We can create textfield by creating an instance of Textfield class. The TextComponent is a superclass of TextField that provides common set of methods used by Textfield.

Text Classes User Interface

import java.awt.*; 
 class Textfieldframe extends Frame 
 { 
       Textfieldframe() 
      { 
             setLayout(new FlowLayout()); 
             Label lblUserid = new Label("Userid"); 
             TextField TxtUserid = new TextField(10); 
             Label lblpassword = new Label("password"); 
             TextField Txtpassword = new TextField("Mr Thakur",13); 
             Txtpassword.setEchoChar('*'); 
             add(lblUserid); add(TxtUserid); 
             add(lblpassword); add(Txtpassword); 
      } 
 } 
    class TextFieldsJavaExample 
    { 
          public static void main(String args[]) 
         { 
               Textfieldframe frame = new Textfieldframe(); 
               frame.setTitle("Text Fields in Java Example"); 
               frame.setSize(220,150); 
               frame.setResizable(false);  
               frame.setVisible(true); 
         } 
    } 
 

Labels are the simplest of all the AWT components. A label is a component that may contain uneditable text. They are generally limited to single-line messages (Labels, short notes, etc.). They are usually used to identify components. For example: In large GUI, it can be difficult to identify the purpose of every component unless the GUI designer provides labels (i.e. text information stating the purpose of each component).

Unlike any other component, labels do not support any interaction with the user and do not fire any events. So, there is no listener class for the labels .We can create label by creating an instance of Label class.The syntax for creating labels is as shown below:

Label label=new Label();
Label label=new Label(String str);
Label label=new Label(String str, int alignment);

The first form creates a blank label. The other two constructors create labels with the specified string; the third constructor specifies how text is aligned within the label. So, the second argument int.alignment will take the values LabeI.RIGHT, Label.LEFT and LabeI.CENTER, which are constants defined in the Label class. The string used in the label can be obtained using the method get Text(). To set a text for a label the method label.setText(“First Label”); is used.

The Label has no surrounding border that might indicate that it’s an editable text object. It also has virtually no use in user interaction. For example, you wouldn’t normally attempt to detect mouse clicks or other events over the Label.

AWT Label Interface

import java.awt.*; 
 class Labelframe extends Frame 
 { 
       Labelframe() 
       { 
          setLayout(new FlowLayout()); 
          Label lblText = new Label("Lable Text"); 
          Label lblTextAlign = new Label("RightAlignment",Label.RIGHT); 
          add(lblText); 
          add(lblTextAlign); 
       } 
 } 
     class LabelJavaAwt  
     {      
          public static void main(String args[]) 
         { 
             Labelframe frame = new Labelframe(); 
             frame.setTitle("Label Component"); 
             frame.setSize(150,150); 
             frame.setVisible(true); 
         } 
     } 

In this java Example, we have created a class named MyFrame that extends the Frame class. The constructor of the MyFrame class contains the statements that constructs the user interface.

The statements

FlowLayout layout = new Flowlayout();

setLayout(layout);

sets the layout manager for the container object (i.e. Frame).The layout manager arranges the GUI components in the window i.e. it determines the position and size of all the components in the container. The first statement creates an object of the class Flowlayout. In this layout manager, the components are arranged in the container (i.e. frame) from left to right, then on the next line when there is no more space. The setLayout () method defined in java.awt.Container class used in the second statement sets the new layout manager for the frame. The statements used for creating and setting layout can be combined as follows,

setLayout(new FlowLayout);

The statement,

MyFrame frame = new MyFrame();

in the main () method instantiates an object of MyFrame class which invokes the default constructor. This constructor sets the Flowlayout of the frame and adds two buttons using the add () method with labels OK and Cancel into it.

The statement,

frame.setTitle(“Extending Frame Class in Java Example”};

sets the specified argument as the title of the frame. The other statements in the main () method work as usual.

import java.awt.*; 
 class Myframe extends Frame 
 { 
      Myframe() 
      { 
         FlowLayout layout = new FlowLayout();  
         setLayout(layout);  
         Button ok = new Button("OK"); 
         Button cancel = new Button("Cancel"); 
         add(ok);     
         add(cancel); 
      } 
 } 
 class ExtendingFrameClass  
 { 
      public static void main(String args[]) 
      { 
          Myframe frame = new Myframe(); 
          frame.setTitle("Extending Frame Class in Java Example"); 
          frame.setSize(350,150); 
          frame.setVisible(true); 
      } 
 } 
 

In order to add a component to a container, first create an instance of the desired component and then call the add () method of the Container class to add it to a window. The add () method has many forms and one of these is.

Component add (Component c)

This method adds an instance of component (i.e. c) to the container. The component added is automatically visible whenever its parent window is displayed.

import java.awt.*; 
 class AddComponent 
 { 
     public static void main(String args[]) 
     { 
        Frame frame = new Frame("Add Components to a Container");  
        Button button = new Button("OK"); 
        frame.add(button);  
        frame.setSize(300,250); 
        frame.setVisible(true);   
      } 
 }