Java Class forName() Method

The Class.forName() method in Java is used to dynamically load and link a class at runtime using its fully qualified name.

Table of Contents

1. Introduction
2. forName() Method Syntax
3. Understanding forName()
4. Examples
   • Basic Usage
   • Handling Exceptions
   • Using a Specific Class Loader
5. Real-World Use Case
6. Conclusion

Introduction

The Class.forName() method is part of the java.lang.Class class and is used to dynamically load a class by its fully qualified name. This is particularly useful in scenarios where the class to be loaded is not known at compile time, such as in plugin systems or frameworks that need to load classes based on configuration or user input.

forName() Method Syntax

The syntax for the forName() method is as follows:

1. Basic forName() Method:

public static Class<?> forName(String className) throws ClassNotFoundException

2. Advanced forName() Method with Class Loader and Initialization Options:

public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException

Parameters:

• Basic forName(String className):

  • className: The fully qualified name of the desired class.

• Advanced forName(String name, boolean initialize, ClassLoader loader):

  • name: The fully qualified name of the desired class.
  • initialize: If true, the class will be initialized; if false, the class will not be initialized.
  • loader: The class loader to use for loading the class.

Returns:

• The Class object representing the loaded class.

Throws:

• ClassNotFoundException if the class cannot be located.

Understanding forName()

The forName() method dynamically loads and links the specified class. The class name must be fully qualified, including the package name. If the basic forName() method is used, the class is initialized by default. The advanced method allows specifying whether the class should be initialized and which class loader to use.

Examples

Basic Usage

To demonstrate the basic usage of forName(), we will dynamically load a class using its fully qualified name.

Example

public class ForNameExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.util.ArrayList");
            System.out.println("Class loaded: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Output:

Class loaded: java.util.ArrayList

Handling Exceptions

When using forName(), it's important to handle the ClassNotFoundException that is thrown if the class cannot be found.

Example

public class ForNameExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.NonExistentClass");
            System.out.println("Class loaded: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            System.out.println("Class not found: " + e.getMessage());
        }
    }
}

Output:

Class not found: com.example.NonExistentClass

Using a Specific Class Loader

The advanced version of forName() allows specifying a class loader and whether to initialize the class.

Example

public class ForNameWithClassLoaderExample {
    public static void main(String[] args) {
        try {
            ClassLoader classLoader = ForNameWithClassLoaderExample.class.getClassLoader();
            Class<?> clazz = Class.forName("java.util.HashMap", false, classLoader);
            System.out.println("Class loaded: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Output:

Class loaded: java.util.HashMap

Real-World Use Case

Plugin System

In a real-world scenario, you might use Class.forName() to dynamically load plugin classes specified in a configuration file.

Example

import java.util.Properties;
import java.io.InputStream;
import java.io.IOException;

public class PluginLoader {
    public static void main(String[] args) {
        Properties properties = new Properties();
        try (InputStream input = PluginLoader.class.getResourceAsStream("/plugins.properties")) {
            properties.load(input);
            String pluginClassName = properties.getProperty("plugin.class");

            Class<?> pluginClass = Class.forName(pluginClassName);
            Runnable plugin = (Runnable) pluginClass.getDeclaredConstructor().newInstance();
            plugin.run();
        } catch (ClassNotFoundException | IOException | ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

plugins.properties file:

plugin.class=com.example.MyPlugin

Output (assuming com.example.MyPlugin implements Runnable and has a no-argument constructor):

Running MyPlugin...

Conclusion

The Class.forName() method in Java provides a powerful way to dynamically load and link classes at runtime using their fully qualified names. By using this method, you can implement dynamic class loading in various scenarios, such as plugin systems, frameworks, or applications that need to load classes based on configuration or user input.