Applet Life Cycle in Java

In Java, an applet is a special type of program embedded in the web page

to generate dynamic content. Applet is a class in Java.

The applet life cycle can be defined as the process of how the object is
created, started, stopped, and destroyed during the entire execution of its
application. It basically has five core methods namely init(), start(), stop(),
paint() and destroy().These methods are invoked by the browser to execute.

Along with the browser, the applet also works on the client side, thus
having less processing time.

Methods of Applet Life Cycle

There are five methods of an applet life cycle, and they are:

o init(): The init() method is the first method to run that initializes the
applet. It can be invoked only once at the time of initialization. The
web browser creates the initialized objects, i.e., the web browser (after
 checking the security settings) runs the init() method within the
applet.
o start(): The start() method contains the actual code of the applet and
starts the applet. It is invoked immediately after the init() method is
invoked. Every time the browser is loaded or refreshed, the start()
method is invoked. It is also invoked whenever the applet is
maximized, restored, or moving from one tab to another in the
browser. It is in an inactive state until the init() method is invoked.
o stop(): The stop() method stops the execution of the applet. The stop
() method is invoked whenever the applet is stopped, minimized, or
moving from one tab to another in the browser, the stop() method is
invoked. When we go back to that page, the start() method is invoked
again.
o destroy(): The destroy() method destroys the applet after its work is
done. It is invoked when the applet window is closed or when the tab
containing the webpage is closed. It removes the applet object from
memory and is executed only once. We cannot start the applet once
it is destroyed.
o paint(): The paint() method belongs to the Graphics class in Java. It is
used to draw shapes like circle, square, trapezium, etc., in the applet.
It is executed after the start() method and when the browser or applet
windows are resized.

Sequence of method execution when an applet is executed:

1. init()
2. start()
3. paint()

Sequence of method execution when an applet is executed:

 1. stop()
2. destroy()

Applet Life Cycle Working

o The Java plug-in software is responsible for managing the life cycle of
an applet.
o An applet is a Java application executed in any web browser and
works on the client-side. It doesn't have the main() method because it
runs in the browser. It is thus created to be placed on an HTML page.
o The init(), start(), stop() and destroy() methods belongs to
the applet.Applet class.
o The paint() method belongs to the awt.Component class.
o In Java, if we want to make a class an Applet class, we need to extend
the Applet
o Whenever we create an applet, we are creating the instance of the
existing Applet class. And thus, we can use all the methods of that
class.

Flow of Applet Life Cycle:

These methods are invoked by the browser automatically. There is no need
to call them explicitly.
class TestAppletLifeCycle extends Applet {
public void init() {
// initialized objects
}
public void start() {
// code to start the applet
}
public void paint(Graphics graphics) {
// draw the shapes
}
public void stop() {
// code to stop the applet
}
public void destroy() {
// code to destroy the applet
} }

1. import java.applet.Applet;
2. import java.awt.Graphics;
3. public class First extends Applet{
4.
5. public void paint(Graphics g){
6. g.drawString("welcome",150,150);
7. }
8.
9. }

c:\>javac First.java
c:\>appletviewer First.java
Java AWT (Abstract Window Toolkit) is an API to develop Graphical User
Interface (GUI) or windows-based applications in Java.

Java AWT components are platform-dependent i.e. components are

displayed according to the view of operating system. AWT is heavy weight
i.e. its components are using the resources of underlying operating system
(OS).

The java.awt package provides classes for AWT API such

as TextField, Label, TextArea, RadioButton, CheckBox, Choice, List etc.

The AWT tutorial will help the user to understand Java GUI programming in
simple and easy steps.

Java AWT Hierarchy

The hierarchy of Java AWT classes are given below.
Components
All the elements like the button, text fields, scroll bars, etc. are called
components. In Java AWT, there are classes for each component as shown
in above diagram. In order to place every component in a particular
position on a screen, we need to add them to a container.

Container
The Container is a component in AWT that can contain another
components like buttons, textfields, labels etc. The classes that extends
Container class are known as container such as Frame, Dialog and Panel.

It is basically a screen where the where the components are placed at their
specific locations. Thus it contains and controls the layout of components.

Types of containers:

There are four types of containers in Java AWT:

1. Window
2. Panel
3. Frame
4. Dialog

Window

The window is the container that have no borders and menu bars. You must
use frame, dialog or another window for creating a window. We need to
create an instance of Window class to create this container.
Panel

The Panel is the container that doesn't contain title bar, border or menu
bar. It is generic container for holding the components. It can have other
components like button, text field etc. An instance of Panel class creates a
container, in which we can add components.

Frame

The Frame is the container that contain title bar and border and can have
menu bars. It can have other components like button, text field, scrollbar
etc. Frame is most widely used container while developing an AWT
application.

Useful Methods of Component Class

Method Description

public void add(Component c) Inserts a component on this component.

public void setSize(int width,int Sets the size (width and height) of the
height) component.

public void Defines the layout manager for the

setLayout(LayoutManager m) component.

public void setVisible(boolean Changes the visibility of the component, by

status) default false.

Java AWT Example

To create simple AWT example, you need a frame. There are two ways to
create a GUI using Frame in AWT.

AWT Example by Inheritance

 Let's see a simple example of AWT where we are inheriting Frame class.
Here, we are showing Button component on the Frame.

AWTExample1.java

// importing Java AWT class

import java.awt.*;
// extending Frame class to our class AWTExample1
public class AWTExample1 extends Frame {
// initializing using constructor
AWTExample1() {
// creating a button
Button b = new Button("Click Me!!");
// setting button position on screen
b.setBounds(30,100,80,30);
1.
// adding button into frame
add(b);

// frame size 300 width and 300 height

setSize(300,300);

// setting the title of Frame

setTitle("This is our basic AWT example");

// no layout manager
setLayout(null);

// now frame will be visible, by default it is not visible

setVisible(true);
}

// main method
public static void main(String args[]) {

// creating instance of Frame class

AWTExample1 f = new AWTExample1();