Introduction

In this lesson, we delve into the Import Statement in Java, exploring its purpose, syntax, and its importance in leveraging both Java's built-in libraries and custom packages. Understanding imports is essential for writing organized, modular, and efficient Java code, allowing developers to use code from other classes without needing to fully qualify each reference.

Purpose of the Import Statement

The import statement in Java serves a vital function: it allows developers to access classes and interfaces from other packages without needing to specify their full package names. This leads to cleaner and more readable code, especially in larger projects where class names might otherwise become cumbersome.

Regular vs. Static Imports

Import statements can be categorized into two types: regular imports and static imports.

Regular Imports:

• These are used for accessing classes from other packages. The syntax typically follows:

  import package_name.ClassName;
  

Static Imports : Static imports allow you to access static variables and methods without referencing the class name. This can simplify code, especially when you frequently use constants or utility methods. The syntax is: java import static package_name.ClassName.staticMethod;

• An example of static import usage:

  import static java.lang.Math.PI;
  import static java.lang.Math.sqrt;
  

• This allows you to use PI and sqrt() directly without prefixing them with Math.

Syntax for Importing Classes

You can import a single class or multiple classes from a package. Here’s how to do each:

• Import a single class:

  import java.util.ArrayList;
  

• Import multiple classes: You can list multiple classes in one import statement, separated by commas:

  import java.util.ArrayList;
  import java.util.HashMap;
  

• Importing all classes in a package: This is done using the wildcard *:

  import java.util.*;
  

  This will give you access to all classes within the java.util package, such as ArrayList, HashMap, Date, etc.

Common Java Libraries to Enhance Functionality

Java provides a rich set of libraries that enhance its capabilities. Here are a few key libraries you might find useful:

• java.lang: Core classes like String, Math, and System are in this package, imported automatically.
• java.util: Contains utility classes such as collections framework and date-time utilities.
• java.io: Useful for input and output functionalities, such as file operations.
• java.net: Classes for networking operations, such as creating sockets.
• java.sql: For accessing and processing data stored in a relational database.

Example

Let’s see a practical example where we leverage the import statement for functionalities provided by the java.util package:

import java.util.ArrayList;
import java.util.Collections;

public class ExampleImport {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(5);
        numbers.add(15);

        // Sorting the list using Collections utility
        Collections.sort(numbers);

        System.out.println("Sorted Numbers: " + numbers);
    }
}

Explanation of Code

• Here, we import ArrayList and Collections from the java.util package.
• We create an ArrayList of integers, add some numbers, and then sort them using the Collections.sort() method.
• The output of running this program would be:

Sorted Numbers: [5, 10, 15]

Summary / Key Takeaways

In this lesson on The Import Statement in Java, you have learned:

• Purpose of the import statement: Simplifies access to classes in Java.
• Regular vs. static imports: Differentiates how classes and static members are accessed.
• Syntax for importing classes: Various methods to import single, multiple, or all classes.
• Using wildcard imports: Efficiently importing entire packages for easier access.
• Common Java libraries: Essential libraries that extend Java's core functionality.
• Practical application: How to implement the import statement in a Java program to utilize existing Java classes effectively.