\n1.<\/b>
AWT<\/code> API was introduced in JDK 1.0. Most of the AWT<\/code> components have become obsolete and should be replaced by newer Swing components.
\n2.<\/b> Swing API, a much more comprehensive set of graphics libraries that enhances the AWT, was introduced as part of Java Foundation Classes (JFC) after the release of JDK 1.1. JFC consists of Swing, Java2D, Accessibility, Internationalization, and Pluggable Look-and-Feel Support APIs. JFC was an add-on to JDK 1.1 but has been integrated into core Java since JDK 1.2.<\/p>\nOther than AWT\/Swing Graphics APIs provided in JDK, others have also provided Graphics APIs that work with Java, such as Eclipse’s Standard Widget Toolkit (SWT) (used in Eclipse), Google Web Toolkit (GWT) (used in Android), 3D Graphics API such as Java bindings for OpenGL (JOGL) and Java3D.<\/p>\n
2 GUI Creation<\/h2>\n
In this example we will learn how to create a GUI using eclipse in JAVA.<\/p>\n
2.1 Setup<\/h3>\n
Prerequisite: <\/b>
\nThis example is developed on Eclipse therefore a compatible Eclipse IDE is required to be installed on the system.<\/p>\n
We also need WindowBuilder tool to be installed on Eclipse IDE for the easiness of the work.
\nFollowing Steps are required to install the WindowBuilder tool.<\/p>\n
\n- Go to Eclipse \u2192Help\u2192 Install New Software\n
![\"Installing](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2016\/06\/Screenshot-2-1.jpg\")
<\/a>Installing WindowBuilder Tool<\/figcaption><\/figure><\/li>\n- Select your version of eclipse version\/download\/eclipse.org\/release\/eclipse version, For example, Mars \u2013 http:\/\/download.eclipse.org\/releases\/mars<\/b><\/li>\n
- Select General purpose tools<\/b> from the dropdown and click next.\n
![\"Installing](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2016\/07\/G1.jpg\")
<\/a>Installing WindowBuilder Tool<\/figcaption><\/figure><\/li>\n<\/ul>\nThis will take some time to install the software, so you have to restart eclipse in order to see the changes.<\/p>\n
2.2 Programming GUI with AWT<\/h3>\n
Java Graphics APIs – AWT and Swing – provide a huge set of reusable GUI components, such as button, text field, label, choice, panel and frame for building GUI applications. You can simply reuse these classes rather than re-invent the wheels. I shall start with the AWT<\/code> classes before moving into Swing to give you a complete picture. I have to stress that AWT<\/code> component classes are now obsoleted by Swing’s counterparts.<\/p>\n2.2.1 AWT Packages<\/h4>\n
AWT is huge! It consists of 12 packages (Swing is even bigger, with 18 packages as of JDK 1.8). Fortunately, only 2 packages – java.awt and java.awt.event – are commonly-used.
\n1.The java.awt package contains the core AWT graphics classes:<\/p>\n
\n- GUI Component classes (such as Button, TextField, and Label),<\/li>\n
- GUI Container classes (such as Frame, Panel, Dialog and ScrollPane),<\/li>\n
- Layout managers (such as FlowLayout, BorderLayout and GridLayout),<\/li>\n
- Custom graphics classes (such as Graphics, Color and Font).<\/li>\n<\/ul>\n
2.The java.awt.event package supports event handling:<\/p>\n
\n- Event classes (such as ActionEvent, MouseEvent, KeyEvent and WindowEvent),<\/li>\n
- Event Listener Interfaces (such as ActionListener, MouseListener, KeyListener and WindowListener),<\/li>\n
- Event Listener Adapter classes (such as MouseAdapter, KeyAdapter, and WindowAdapter).<\/li>\n<\/ul>\n
AWT provides a platform-independent and device-independent interface to develop graphic programs that runs on all platforms, such as Windows, Mac, and Linux.<\/p>\n
2.2.2 Containers and Components<\/h4>\n
There are two types of GUI elements:
\n1. Component: Components are elementary GUI entities (such as Button, Label, and TextField.)
\n2. Container: Containers (such as Frame and Panel) are used to hold components in a specific layout (such as flow or grid). A container can also hold sub-containers.<\/p>\n
GUI components are also called controls (Microsoft ActiveX Control), widgets (Eclipse’s Standard Widget Toolkit, Google Web Toolkit), which allow users to interact with (or control) the application through these components (such as button-click and text-entry).<\/p>\n
A Frame is the top-level container of an AWT program. A Frame has a title bar (containing an icon, a title, and the minimize\/maximize\/close buttons), an optional menu bar and the content display area. A Panel is a rectangular area used to group related GUI components in a certain layout. In the above figure, the top-level Frame contains two Panels. There are five components: a Label (providing description), a TextField (for users to enter text), and three Buttons (for user to trigger certain programmed actions).
<\/div> <\/div><\/p>\nIn a GUI program, a component must be kept in a container. You need to identify a container to hold the components. Every container has a method called add(Component c). A container (say aContainer) can invoke aContainer.add(aComponent) to add aComponent into itself. For example,
\nMyGUIProgram.java<\/em><\/span><\/p>\nPanel panel = new Panel(); \/\/ Panel is a Container\r\nButton btn = new Button(\"Press\"); \/\/ Button is a Component\r\npanel.add(btn); \/\/ The Panel Container adds a Button Component\r\n\r\n<\/pre>\n2.2.2 AWT Container Classes<\/h4>\n
Top-Level Containers: Frame, Dialog and Applet <\/b>
\nEach GUI program has a top-level container. The commonly-used top-level containers in AWT are Frame, Dialog and Applet:<\/p>\n\n\n- A Frame provides the “main window” for the GUI application, which has a title bar (containing an icon, a title, the minimize, maximize\/restore-down and close buttons), an optional menu bar, and the content display area. To write a GUI program, we typically start with a subclass extending from
java.awt.Frame<\/code> to inherit the main window as follows:<\/li>\n<\/ul>\n<\/ul>\nMyGUIProgram.java<\/em><\/span><\/p>\nimport java.awt.Frame; \/\/ Using Frame class in package java.awt\r\n\r\n\/\/ A GUI program is written as a subclass of Frame - the top-level container\r\n\/\/ This subclass inherits all properties from Frame, e.g., title, icon, buttons, content-pane\r\npublic class MyGUIProgram extends Frame {\r\n \r\n \/\/ Constructor to setup the GUI components\r\n public MyGUIProgram() { ...... }\r\n\r\n \/\/ Other methods\r\n ......\r\n ......\r\n\r\n \/\/ The entry main() method\r\n public static void main(String[] args) {\r\n \/\/ Invoke the constructor (to setup the GUI) by allocating an instance\r\n new MyGUIProgram();\r\n }\r\n}\r\n\r\n<\/pre>\n\n- An AWT Dialog is a “pop-up window” used for interacting with the users. A Dialog has a title-bar (containing an icon, a title and a close button) and a content display area, as illustrated.<\/li>\n
- An AWT Applet (in package java.applet) is the top-level container for an applet, which is a Java program running inside a browser. Applet will be discussed in the later chapter.<\/li>\n<\/ul>\n
Secondary Containers: Panel and ScrollPane <\/b>
\nSecondary containers are placed inside a top-level container or another secondary container. AWT also provide these secondary containers:<\/p>\n\n\n- Panel: a rectangular box under a higher-level container, used to layout a set of related GUI components in pattern such as grid or flow.<\/li>\n
- ScrollPane: provides automatic horizontal and\/or vertical scrolling for a single child component.<\/li>\n<\/ul>\n<\/ul>\n
2.2.2 AWT Component Classes<\/h4>\n
AWT provides many ready-made and reusable GUI components. The frequently-used are: Button, TextField, Label, Checkbox, CheckboxGroup (radio buttons), List, and Choice, as illustrated below.<\/p>\n
AWT GUI Component:java.awt.Label <\/b>
\nA java.awt.Label<\/code> provides a text description message. Take note that System.out.println() prints to the system console, not to the graphics screen. You could use a Label to label another component (such as text field) or provide a text description.<\/p>\nCheck the JDK API specification for java.awt.Label.<\/p>\n
Below is how a label will look like:<\/p>\n
![\"Inserting](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2016\/07\/G2.jpg\")
<\/a>Inserting a Label<\/figcaption><\/figure><\/p>\nConstructors <\/b><\/p>\n\n\n\n- public Label(String strLabel, int alignment); \/\/ Construct a Label with the given text String, of the text alignment<\/li>\n
- public Label(String strLabel); \/\/ Construct a Label with the given text String<\/li>\n
- public Label(); \/\/ Construct an initially empty Label<\/li>\n<\/ul>\n<\/ul>\n<\/ul>\n
The Label class has three constructors:
\n1.The first constructor constructs a Label object with the given text string in the given alignment. Note that three static constants Label.LEFT<\/code>, Label.RIGHT<\/code>, and Label.CENTER<\/code> are defined in the class for you to specify the alignment (rather than asking you to memorize arbitrary integer values).
\n2.The second constructor constructs a Label object with the given text string in default of left-aligned.
\n3.The third constructor constructs a Label object with an initially empty string. You could set the label text via the setText() <\/code> method later.<\/p>\nConstructing a Component and Adding the Component into a Container<\/b>
\nThree steps are necessary to create and place a GUI component:
\n1.Declare the component with an identifier (name);
\n2.Construct the component by invoking an appropriate constructor via the new operator;
\n3.Identify the container (such as Frame or Panel) designed to hold this component. The container can then add this component onto itself via aContainer.add(aComponent) method. Every container has an add(Component) method. Take note that it is the container that actively and explicitly adds a component onto itself, instead of the other way.<\/p>\n
Below is the code to add a label(component) to a frame(container)<\/p>\n
MyGUIProgram.java<\/em><\/span><\/p>\n JLabel lblName = new JLabel(\"Name\");\r\n\t\tlblName.setBounds(93, 67, 46, 14);\r\n\t\tframe.getContentPane().add(lblName);\r\n<\/pre>\nAWT GUI Component: java.awt.Button <\/b><\/p>\n
A java.awt.Button<\/code> is a GUI component that triggers a certain programmed action upon clicking.
\nConstructors<\/b>
\npublic Button(String buttonLabel);
\n\/\/ Construct a Button with the given label
\npublic Button();
\n\/\/ Construct a Button with empty label
\nThe Button class has two constructors. The first constructor creates a Button object with the given label painted over the button. The second constructor creates a Button object with no label.<\/p>\nHere is how button will look like:<\/p>\n