• Most modern interfaces are built around the concept of "components" which are reusable widgets that perform some user-interface function. You should be extremely familiar with the ideas of components though if you have worked on any computers since the mid-80s. Common components include Buttons, Scroll Bars, Menu Bars, etc which are all basic to the GUIs you use every day.

• The JDK comes with a fairly diverse set of components already built in which you can easily use by working with the online documentation.

• These components all derive from the abstract base class java.awt.Component. By abstract, I mean that you would never instantiate a Component object. instead, you would extend the Component class in order to build a functional component. The Component class is more of a "generic" Component which contains al of the methods which all components should have.

• Specifically, the Component class defines such things as alignment, background and foreground colors, fonts, size and positioning etc. You should consult the online documentation for the entire list of methods and fields however, we will try to demonstrate most of the important ones in the examples to follow.

• Let's take a look at some of the most often used components provided by the JDK.

Static Text with Label

• The Label class gives you the ability to draw a single line of text in your application. There is not much to it, consider the following example:

import java.awt.*;

public class LabelExample
  {
  public static void main(String[] args)
    {
    Frame baseFrame = new Frame();
    baseFrame.setLayout(new GridLayout(3,1));
    baseFrame.reshape(10,10,200,200);
    baseFrame.setTitle("Label Example");

    Label labelLeft = new Label("Hello Cyberspace!");
    labelLeft.setForeground(Color.white);
    labelLeft.setBackground(Color.black);

    Label labelRight = new Label("Hello Cyberspace!",
				 Label.RIGHT);
    labelRight.setFont(new Font("Helvetica",
                                 Font.BOLD, 15));

    Label labelCenter = new Label("Hello Cyberspace!",
				  Label.CENTER);

    baseFrame.add(labelLeft);
    baseFrame.add(labelRight);
    baseFrame.add(labelCenter);

    baseFrame.show();
    }
  }

• The previous code yields the following interface:
  

Text Entry Components

• The JDK also provides the TextField and TextArea components which allow you to get user input. They are derived from TextComponent, so if you are looking for a method that should obviously be there, you should check TextComponent right away.

import java.awt.*;

public class TextEntryExample
  {
  public static void main(String[] args)
    {
    Frame baseFrame = new Frame();
    baseFrame.setLayout(new GridLayout(2,1));
    baseFrame.reshape(10,10,200,200);
    baseFrame.setTitle("Label Example");

    TextField myTextField = new TextField();
    myTextField.setText("Here is some " +
             "default and selected text");
    myTextField.setSelectionStart(0);
    myTextField.setSelectionEnd(4);
    myTextField.setEditable(false);

    TextArea myTextArea = new TextArea
        ("The Text Area widget \n" +
         "allows multiple line text entry." +
         "it is also worth \n noting that it " +
         "will dynamically create scroll " +
         "bars \n if the text goes beyond the " +
         "boundaries of the widget");
    baseFrame.add(myTextField);
    baseFrame.add(myTextArea);

    baseFrame.show();
    }
  }

• When compiled and executed, the code above produces the following interface:
  

Check Boxes and Check Box Groups

• The Check Box and Check Box Groups are very familiar components which allow a user to make a choice between several options. The Check Box component is used to give the user the ability to select or unselect some choice. The Check Box group allows the developer to group a set of check boxes in such a way that only one check box can be selected at any one time (On day one, we saw this type of widget in HTML FORM programming under the name "RADIO"). In the following example we create both single check boxes and checkboxes in a group. Notice that you can select or unselect AFC or JDK without affecting any other check boxes. However, you can choose only male or female from the sex group.

  import java.awt.*;
  
  
  public class CheckExample
    {
    public static void main(String[] args)
      {
      Frame baseFrame = new Frame();
      baseFrame.setLayout(new GridLayout(4,1));
      baseFrame.reshape(10,10,200,200);
      baseFrame.setTitle("Check Example");
  
      Checkbox jdkChoice = new Checkbox("JDK");
      Checkbox afcChoice = new Checkbox("AFC");
  
      CheckboxGroup sexGroup = new CheckboxGroup();
      Checkbox maleChoice = new Checkbox("male",
           sexGroup, false);
      Checkbox femaleChoice = new Checkbox("Female",
  	 sexGroup, false);
  
      baseFrame.add(jdkChoice);
      baseFrame.add(afcChoice);
      baseFrame.add(maleChoice);
      baseFrame.add(femaleChoice);
  
      baseFrame.show();
      }
    }
  

  

Choices

• One of the problems with Check Boxes and Check Box Groups is that they take up a lot of space in your interface. If you have a lot of choices, it may be better to present them in a Choice control (similar to the SELECT widget in HTML FORM programming)

  import java.awt.*;
  
  public class ChoiceExample
    {
    public static void main(String[] args)
      {
      Frame baseFrame = new Frame();
      baseFrame.setLayout(new GridLayout(4,1));
      baseFrame.reshape(10,10,200,200);
      baseFrame.setTitle("Choice Example");
  
      Choice choice = new Choice();
      choice.addItem("Selena");
      choice.addItem("Eric");
      choice.addItem("Mark");
  
  
      baseFrame.add(choice);
  
      baseFrame.show();
      }
    }
  

  

Lists

• You will recall that in the SELECT widget in HTML programming, you could select how many choices were visible at any one time using the SIZE attribute. Well, since the Choice widget does not have such an attribute, you need to use a different component if you want that functionality. In the JDK, the List component is used for such circumstances.

  import java.awt.*;
  
  public class ListExample
    {
    public static void main(String[] args)
      {
      Frame baseFrame = new Frame();
      baseFrame.reshape(10,10,200,200);
      baseFrame.setTitle("List Example");
  
      List list = new List(3, true);
      list.addItem("Selena");
      list.addItem("Eric");
      list.addItem("Mark");
      list.addItem("Bob Frog");
  
      baseFrame.add(list);
  
      baseFrame.show();
      }
    }
  
  

  

Menus and Menu Bars

• Menus allow you to organize many related functions in your application in one centralized, easy-to-use interface object. Although Menus come in many forms, the most common menu types are "menu bars".

• Menu bars are particularly common and part of just about every application interface around today. Specifically, most applications will have a menu bar at the top of the screen that allows a user to choose among the major functions.

  import java.awt.*;
  
  public class MenuExample
    {
    public static void main(String[] args)
      {
      Frame baseFrame = new Frame();
      baseFrame.reshape(10,10,200,200);
      baseFrame.setTitle("Menu Example");
  
      MenuBar bar = new MenuBar();
  
      Menu fileMenu = new Menu("File");
      Menu editMenu = new Menu("Edit");
      Menu specialMenu = new Menu("Special");
  
      fileMenu.add(new MenuItem("Open"));
      fileMenu.add(new MenuItem("Save"));
      fileMenu.addSeparator();
      fileMenu.add(new MenuItem("Exit"));
      bar.add(fileMenu);
      bar.add(editMenu);
      bar.add(specialMenu);
  
      baseFrame.setMenuBar(bar);
      baseFrame.show();
      }
    }
  

  

Scrollbars

• Almost without doubt and before you know it, your users will be filling your application with more data than it can possibly display on one screen.

• When this occurs, most programmers rely on some form of scrolling control to allow the user to manipulate the currently viewable portion of an interface object. Scrolling is handled in the JDK by the Scrollbar class. Scrollbars take a little more coding than is realistic for this tutorial. However, you can certainly consult the online documentation and any one of the 200 zillion books on Java for more info.

Buttons

• Buttons are probably the most common interface control in modern user interfaces. They appear in toolbars, in menus, as the up and down arrows in scrollbars, and in all sorts of other places. In fact, it is hard to imagine any interface without a button somewhere.

• The Button class defines a standard push button that uses 3D effects. When the user clicks on the button with the mouse, the button visually depresses and then pops back up when the mouse button is released.

• We have already seen plenty of examples of Buttons and Button code so we won't duplicate it here.

Canvases

• Finally, the Canvas class prepares an area upon which you can draw. We will discuss drawing later. So for now, we will just mention this component.