Exploring the Basics of Applet in Java: A Beginner’s Guide

Applets in Java are small, platform-independent programs that run within web browsers, providing dynamic content and interactivity without requiring installation. These applets were designed to allow developers to create rich web applications, such as real-time data visualization or interactive educational tools, all within a browser environment.

In this blog, you’ll learn about the applet in Java, covering their key features, life cycle, usage, and how to run them using HTML files and Appletviewer.

Strengthen your understanding of Java applets with upGrad’s Software Development courses! Learn everything from basic Java to advanced frameworks, preparing you for the future of tech. Join now and explore endless opportunities.

What is an Applet in Java?

Java applets are lightweight, platform-independent programs that run directly within web browsers. They provide dynamic content through graphical rendering and user interaction, without the need for installation. Additionally, built-in security features ensure safe execution within the browser. 

In 2025, professionals who can use advanced Java programming techniques like applets to streamline business operations will be in high demand. If you're looking to develop skills in programming, here are some top-rated courses to help you get there:

• AI-Driven Full-Stack Development Bootcamp
• Master of Design in User Experience
• Professional Certificate Program in Cloud Computing and DevOps

Note: While Java applets are now deprecated and no longer supported in most browsers, they remain important for understanding legacy systems and the evolution of Java development. 

Now that we understand the basics of Java applets, let's explore their key features that make them unique and valuable in programming.

Key Features of Applet in Java

Applet in Java offers several distinct features that make them suitable for interactive applications on the web. These features allow applets to run within web browsers, interact with users, and display dynamic content.

Let’s explore these key features in more detail.

• Embedded in a Web Page: An online banking application uses a Java applet embedded in an HTML page to display real-time transaction graphs, providing users interactive financial data without requiring any installation.
• Runs in a Browser: A weather applet that fetches and displays live weather data directly in the browser without the need for any external software, relying on the Java Runtime Environment (JRE) installed on the user’s device.
• Platform Independent: A global e-learning platform uses Java applets to deliver interactive course content to students, ensuring seamless access whether they are on Windows, macOS, or Linux operating systems.

Despite their initial success, the popularity of applet in Java began to fade as new web technologies emerged. HTML5, JavaScript, and other technologies quickly overtook Java applets in providing interactive web content. 

For example, you can now achieve animation effects and dynamic content using JavaScript, without the need for a plugin or a separate runtime environment.

Where Are Java Applets Used Today?

Even though the applet in Java has been largely replaced by other technologies, it’s not entirely gone. There are still areas where they are useful:

• Legacy Systems: Older banking applications, educational tools, and simulations that were built with Java applets are still running in some sectors.
• Offline Applications: Certain platforms that rely on Java's ability to run offline or across multiple systems still use applets to this day.

You can get a better hang of Java with upGrad’s free Core Java Basics course. It covers variables, data types, loops, and OOP principles to build strong coding skills. Perfect for aspiring developers, students, and professionals transitioning to Java.

Also Read: Difference Between Applet and Application in Java: Features, Benefits, and Uses

Having explored the basics of applets in Java, it's time to take a closer look at their life cycle and the various phases they undergo.

Life Cycle of Applets in Java

Applet in Java follows a specific life cycle that governs how it is created, executed, and terminated. Its lifecycle is managed by the browser or the environment hosting it.

The life cycle of an applet is made up of several method calls, each of which serves a unique purpose in initializing, running, and shutting down the applet. These methods ensure that the applet runs smoothly and allows developers to manage resources effectively.

Here’s a look at the main phases that happen when an applet in Java starts and stops:

• Initialization: The init() method is called.
• Execution: The start() method is invoked, followed by continuous execution of the paint() method to handle the applet’s graphical rendering.
• Termination: The stop() method is called when the applet is paused, and finally, the destroy() method is invoked when the applet is removed from memory.

The sequence of these method calls ensures that your applet in Java is properly managed throughout its lifecycle.

Key Life Cycle Methods

To dive deeper, let’s explore each of the key methods involved in the applet in Java life cycle:

• init() Method: Initialization Phase
  The init() method is called once when the applet is first loaded into the browser. This is where you define the applet's initial setup. For example, you might set up variables, establish database connections, or load resources. This method runs only once during the applet’s life cycle.
  
  Why it matters: The init() method is essential for setting up the applet’s environment and ensuring everything is ready before any other operations take place.
   
• start() Method: Execution Begins
  Once the init() method completes, the start() method is called. It’s executed whenever the applet is started or when the user returns to the page. In most cases, this method handles tasks that need to be continually updated, such as starting a thread for animations or interactive features.
  
  Why it matters: The start() method is responsible for activating ongoing tasks in the applet, such as animations or periodic updates. Without it, the applet would remain static and inactive.
   
• paint() Method: Rendering Graphics
  The paint() method is called whenever the applet needs to update its graphical output. This method is called frequently, especially after the applet has been resized, uncovered, or when the user triggers any change that requires a re-render.
  
  Why it matters: The paint() method is the heart of rendering visuals in an applet in Java. If you want to draw shapes, display text, or show images, this is the method to override.
   
• stop() and destroy() Methods: Shutting Down
  • stop() Method: This method is invoked when the applet is no longer in the foreground, such as when the user navigates away from the page. It is used to pause any activities like animations or background threads.
     

  • destroy() Method: The destroy() method is called when the applet is permanently removed from memory, usually when the browser window is closed or the applet is destroyed by the browser environment. It is where you clean up resources, such as closing database connections or stopping threads.

     

    Why they matter: These methods ensure that the applet does not waste resources once it’s no longer needed and that it’s gracefully terminated without leaving any open processes.

Also Read: Java Servlets by Example: Master Lifecycle & Best Practices

Having understood the core life cycle methods, let’s explore a practical Java Applet example to see how these methods are used in action.

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

Java Applets Life Cycle Example

The example below shows the sequence of method calls when the applet starts, runs, and terminates.

import java.applet.Applet;
import java.awt.Graphics;

public class AppletLifeCycleExample extends Applet {
    // Initialization method
    public void init() {
        System.out.println("Applet Initialized");
    }

    // Start method
    public void start() {
        System.out.println("Applet Started");
    }

    // Paint method to render graphics
    public void paint(Graphics g) {
        g.drawString("Hello, Applet!", 50, 50);
        System.out.println("Applet Painted");
    }

    // Stop method
    public void stop() {
        System.out.println("Applet Stopped");
    }

    // Destroy method
    public void destroy() {
        System.out.println("Applet Destroyed");
    }
}

Output:

Applet Initialized
Applet Started
Applet Painted
Applet Stopped
Applet Destroyed

In this simple example, each method corresponds to a specific stage in the applet in the Java life cycle. First, the init() method is called to initialize the applet, followed by start(), which begins the applet’s execution. The paint() method handles the graphical rendering of content, and eventually, when the applet is stopped and destroyed, the stop() and destroy() methods are invoked.

With the life cycle of a Java applet clear, let's discuss the process of running your first applet in Java and seeing it in action.

How To Run an Applet in Java?

If you’ve written an applet in Java and are ready to see it in action, you need to know how to run it properly. In the past, Java applets were executed within browsers or with tools like Appletviewer. But as browsers moved away from supporting Java applets, it's important to understand how to run them in both environments.

Here’s how you can get your applet in Java running, step by step.

Running an Applet via an HTML File

One of the most common ways to run an applet in Java is by embedding it within an HTML file. This method makes your applet accessible through a browser that supports Java plugins, although it’s less common nowadays due to security concerns and browser updates.

To embed an applet in Java in an HTML file, follow these steps:

1. Write the Applet Code
First, ensure your Java applet code is ready. Here's a simple example of an applet in Java that displays a message.

import java.applet.Applet;
import java.awt.Graphics;

public class HelloWorldApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello, Applet in Java!", 50, 50);
    }
}

2. Compile the Applet
Next, compile the Java code. Open your terminal (or Command Prompt) and run the following command:

javac HelloWorldApplet.java

This will create a file called HelloWorldApplet.class, which is your compiled applet.

3. Create an HTML File
After compiling the applet, create an HTML file to embed the applet. Here's the HTML code you’ll use:

<html>
<head>
    <title>Java Applet Example</title>
</head>
<body>
    <h2>Java Applet Example</h2>
    <applet code="HelloWorldApplet.class" width="300" height="300">
    </applet>
</body>
</html>

4. Open the HTML File in a Browser
Once your HTML file is ready, open it in a browser that supports Java applets (such as older versions of Firefox or Internet Explorer). You should see the applet running in the browser with the message “Hello, Applet in Java!” displayed.

Even though most modern browsers no longer support Java applets, this method was a common way to run applets in Java back in the day. For now, this method remains useful for learning about applets and legacy systems.

Running an Applet Using Appletviewer Tool

The Appletviewer tool is a command-line utility provided by the Java Development Kit (JDK). It was designed specifically to run applets in Java outside the browser. This is especially helpful for testing and debugging applets without worrying about browser support. Here's how you can use the Appletviewer tool to run an applet in Java:

1. Ensure JDK is Installed
To use Appletviewer, you must have the Java Development Kit (JDK) installed. If you haven't installed it yet, download the JDK from Oracle's website and follow the installation instructions for your system.

2. Write Your Applet Code
Here’s a simple example of an applet in Java:

import java.applet.Applet;
import java.awt.Graphics;

public class HelloWorldApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello, Applet in Java!", 50, 50);
    }



}

3. Compile the Applet
Use the terminal or command prompt to compile your applet in Java:

javac HelloWorldApplet.java

4. Create an Applet HTML File
Even when using Appletviewer, you still need to create an HTML file that tells the tool how to locate and run your applet. Here’s the corresponding HTML file:

<html>
<head>
    <title>AppletViewer Example</title>
</head>
<body>
    <h2>Running Applet in Java</h2>
    <applet code="HelloWorldApplet.class" width="300" height="300">
    </applet>
</body>
</html>

5. Run the Applet Using Appletviewer
Now that you have both the .class file and the HTML file, use the Appletviewer tool to run the applet:

appletviewer HelloWorldApplet.html

This command will launch the Appletviewer tool and display the applet in a window.

6. View the Output
Once you run the above command, you will see your applet in Java rendered by the Appletviewer. The output will display “Hello, Applet in Java!” on the window, just like it would in a browser (before Java applets were deprecated).

Still writing messy or repetitive Java code? That’s a sign you need stronger OOP fundamentals. upGrad’s Java Object-Oriented Programming course helps you master classes, inheritance, and encapsulation, enabling you to write cleaner, modular code. 

Also Read: How to Code, Compile, and Run Java Projects in 2025

Now that you know how to run an applet in Java, let's explore the key packages essential for creating and managing Java applets effectively.

Key Packages for Java Applets

Applet in Java relies on a few core packages that make the development process simpler and more efficient. These packages are built into the Java Development Kit (JDK) and offer a range of essential tools that handle everything from drawing graphics to creating interactive components. 

Below are the essential packages you'll work with when creating applet in Java:

1. java.applet.Applet: Base Class for Applets

The java.applet.Applet class is the foundation of every applet in Java. It provides the essential methods and structure needed to create applets. All applets must extend this class in order to be recognized as applets by the Java Runtime Environment (JRE).

• Key Role: The Applet class provides the framework for managing the applet lifecycle. It handles methods like init(), start(), stop(), and destroy(). These methods manage initialization, execution, and termination of the applet.
• Why it matters: You cannot create an applet in Java without extending this base class. It forms the backbone of your applet's functionality, making it the starting point for any applet creation.

2. java.awt.Graphics: Essential for Rendering Graphics in Applets

Once you’ve extended the Applet class, you’ll want to display something to the user. This is where the java.awt.Graphics package comes into play. It provides the classes needed to render 2D animation/graphics on the applet window.

• Key Role: The Graphics class allows you to draw shapes, text, images, and more. It is the key to rendering content in an applet in Java. You’ll use the paint() method, which accepts a Graphics object as an argument, to render visual components in your applet.
• Real-World Use Case: In a financial application, a developer might use Graphics to draw a graph or chart that updates dynamically based on user inputs. Similarly, in games, developers use the Graphics class to create real-time animations and other visual elements.
• Why it matters: Without the Graphics class, you wouldn't be able to create visual content for the user. This class is essential for adding interactivity and presenting data in a way that users can easily understand.

3. java.awt: GUI Components and Event-Handling

The java.awt package is a comprehensive package that includes the classes needed for user interface components (GUI) and event-handling. It provides everything from buttons and text fields to more complex layout managers. You’ll often use an applet in Java with components from this package to interact with users.

• Key Role: It contains various user interface components like Button, TextField, Label, and Panel. It also includes event-handling classes such as MouseListener and ActionListener that help capture and respond to user interactions. By integrating these components, you can make your applet in Java interactive and user-friendly.
• Real-World Use Case: In educational apps or forms, applets in Java might use buttons (Button) or input fields (TextField) to collect data from users. You would attach event listeners to these components to capture clicks or key presses and trigger responses accordingly.
• Why it matters: The java.awt package is essential for making your applet in Java more interactive. Without it, your applet would be limited to just static graphics and text.

When developing an applet in Java, these packages work together to provide a functional and interactive user experience. The Applet class gives you the basic applet structure, Graphics lets you render visuals, and java.awt helps you create interactive GUI components. Combining these packages allows you to create powerful, engaging applets.

Also Read: 50 Java Projects With Source Code in 2025

Having learned about the key Java applet packages, you're ready to take the next step. Join upGrad and become an expert in Java applets and beyond!

Become an Expert in Applet in Java with upGrad!

Understanding the applet in Java gives you a solid foundation in how interactive web applications were originally built. To deepen your knowledge, try building simple applets and experiment with different Java packages, like java.awt.Graphics and event handling. This hands-on approach will reinforce the concepts and improve your practical skills.

In addition to the specialized courses mentioned above, here are some additional free courses to help you get started.

• Learn Basic Python Programming
• Java Object-oriented Programming
• JavaScript Basics from Scratch
• Advanced JavaScript for All

Still struggling to find the right Java software development course to match your goals in 2025? Reach out to upGrad for personalized counseling and valuable insights, or visit your nearest upGrad offline center for more details.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

References:
https://www.infoworld.com/article/3623579/java-applet-api-heads-for-the-exit.html    
https://incusdata.com/blog/life-and-death-of-java-applets    
https://openjdk.org/jeps/504