Java Applet Basics

Java - Applet Basics (Deprecated Technology)

Important Note: Java Applets are heavily deprecated technology. Modern web browsers have removed support for the NPAPI plugin required by applets due to significant security vulnerabilities and the rise of superior web technologies. You should NOT use Applets for new development and avoid them whenever possible. This section is provided for historical context only.

Historically, an Applet was a small Java program designed to be embedded within an HTML web page and run inside a web browser. Applets allowed adding interactive features and complex computations to web pages before modern JavaScript frameworks became prevalent.

Key Historical Characteristics:

• Extended the java.applet.Applet class (or later, javax.swing.JApplet for Swing components).
• Did not have a main() method; execution was managed by the browser/plugin.
• Embedded in HTML using the <applet> tag (later <object> or <embed>).
• Ran within a security sandbox, restricting access to local system resources (file system, network connections, etc.) unless explicitly granted permissions (which was complex and often insecure).
• Required a Java Virtual Machine (JVM) plugin to be installed and enabled in the browser.

Why Applets Became Obsolete:

• Security Risks: The browser plugin model was a major source of security vulnerabilities.
• Poor User Experience: Required plugin installation, slow loading times, inconsistent behavior across browsers/platforms.
• Lack of Browser Support: All major browsers (Chrome, Firefox, Edge, Safari) have removed NPAPI plugin support.
• Better Alternatives: Modern web development relies on HTML5, CSS3, JavaScript (with powerful frameworks like React, Angular, Vue), and WebAssembly for rich client-side functionality.

Historical Life Cycle of an Applet

The browser environment managed the applet’s lifecycle through specific methods inherited from the Applet class, which developers could override:

• init(): Called once when the applet was first loaded. Used for initialization tasks (setting up resources, parsing parameters).
• start(): Called after init() and whenever the user navigated back to the applet’s page. Used to start animations, threads, or other active processes.
• stop(): Called when the user navigated away from the page. Used to pause animations, stop threads, and release temporary resources.
• destroy(): Called once when the applet was being unloaded permanently (e.g., browser closing). Used for final cleanup of resources.
• paint(Graphics g): (Inherited from AWT Component) Called whenever the applet’s display area needed to be redrawn. Developers placed drawing code here using the Graphics object.

Historical “Hello, World” Applet Example

Warning: The following code is for historical illustration only and will not run in modern browsers without significant effort using outdated software.

// HelloWorldApplet.java (Historical Example - Do Not Use)
import java.applet.Applet;
import java.awt.Graphics;

/**
 * @deprecated Applets are deprecated technology.
 */
@Deprecated
public class HelloWorldApplet extends Applet {

    // Called by the browser to draw the applet content
    @Override
    public void paint(Graphics g) {
        // Draw the string "Hello World" at position (25, 50)
        g.drawString("Hello World (Applet - Deprecated)", 25, 50);
    }
}

Historical Embedding in HTML

Applets were embedded using tags like <applet>:

<!-- Historical HTML Example - Do Not Use -->
<html>
<head>
    <title>Deprecated Applet Example</title>
</head>
<body>
    <hr>
    <p>Attempting to load a deprecated applet:</p>
    <applet code="HelloWorldApplet.class" width="320" height="120">
        <!-- This text appears if the browser doesn't support applets -->
        Your browser does not support Java Applets (or they are disabled).
    </applet>
    <hr>
</body>
</html>

Historical Features (Parameters, Images, Audio)

Applets had mechanisms for:

• Parameters: Receiving input via <param> tags within the <applet> tag, retrieved using getParameter(String name).
• Images: Loading and displaying images (GIF, JPEG) using getImage() and drawImage(). Requires appropriate permissions if loading from different origins.
• Audio: Playing audio clips (.au, .wav) using getAudioClip() and the AudioClip interface (play(), loop(), stop()).

These features are also obsolete in the context of applets.

Modern Alternatives to Applets

If you need rich client-side functionality in a web browser:

• JavaScript Frameworks/Libraries: Use modern JavaScript (ES6+) along with frameworks like React, Angular, Vue.js, or Svelte to build dynamic user interfaces.
• WebAssembly (Wasm): Compile code written in languages like C++, C#, Rust (and potentially others) to run in the browser at near-native speed for performance-intensive tasks.
• Server-Side Rendering (SSR) / Frameworks: Use server-side technologies (like Java with Spring Boot/Jakarta EE, Node.js, Python/Django, Ruby/Rails) to generate HTML on the server, often combined with JavaScript for client-side enhancements.

If you need a desktop application with Java:

• JavaFX: The modern framework for building cross-platform desktop applications with rich UIs in Java.
• Swing: The older, still widely used framework for Java desktop applications.
• (Java Web Start - Also Deprecated): Was a technology for deploying desktop applications over the web, but is also deprecated and removed from modern Java versions.

In summary, while applets were historically significant, they are now obsolete and insecure. Focus on modern web technologies or Java desktop frameworks like JavaFX for new development.