Topic 11736 min readStructured Tutorial

Java Import Statement

Quick Answer

Import Statement explains in Java programming, the import statement allows you to bring other classes or entire packages into your current source file.

Learning Objectives

Explain the purpose of Import Statement in a practical learning context.
Identify the main ideas, terms, and decisions involved in Import Statement.
Apply Import Statement in a simple real-world scenario or practice task.

Introduction

In Java programming, the import statement allows you to bring other classes or entire packages into your current source file. This helps you use pre-built functionality without rewriting code.

Understanding how to use import statements effectively is essential for organizing your code and accessing Java's extensive libraries.

Code reuse is the essence of software engineering.

What is the Import Statement?

The import statement in Java tells the compiler where to find classes or entire packages that your program needs. It is placed at the beginning of a Java source file, after the package declaration (if any) and before the class definition.

Without import statements, you would have to use fully qualified class names every time you reference a class, which can be cumbersome.

Placed at the top of Java source files.
Allows access to classes from other packages.
Improves code readability and maintainability.

Syntax of Import Statement

The basic syntax of the import statement is straightforward. You specify the keyword 'import' followed by the fully qualified name of the class or package you want to import, ending with a semicolon.

There are two main types of import statements: single-type import and on-demand import.

Single-type import: imports a specific class.
On-demand import: imports all classes from a package using the asterisk (*) wildcard.

Import Statement Syntax Examples
Type	Syntax	Description
Single-type import	import java.util.ArrayList;	Imports only the ArrayList class from java.util package.
On-demand import	import java.util.*;	Imports all classes from the java.util package.

How Import Works in Java

The import statement does not actually copy code into your file. Instead, it tells the compiler where to look for classes when compiling your program.

If you do not import a class, you must use its fully qualified name every time you reference it.

Import statements are compile-time directives.
They do not affect runtime performance.
Fully qualified names can be used instead of imports.

Examples of Import Statements

Here are some practical examples demonstrating how to use import statements in Java.

Single-type Import Example

This example imports the ArrayList class from the java.util package and uses it to create a list.

On-demand Import Example

This example imports all classes from the java.util package and uses both ArrayList and HashMap classes.

Best Practices for Using Import Statements

Using import statements wisely can improve code clarity and avoid conflicts.

Prefer single-type imports for clarity and to avoid namespace collisions.
Avoid excessive use of on-demand imports as they can make code less readable.
Organize imports alphabetically for better maintainability.
Use IDE features to optimize and manage imports automatically.

Common Mistakes with Import Statements

Beginners often make mistakes with import statements that can cause compilation errors or confusion.

Forgetting to import a class and trying to use it directly.
Using on-demand imports excessively, leading to ambiguous references.
Importing classes that are not used in the code.
Confusing import statements with package declarations.

Practical Example

This example imports only the ArrayList class and uses it to create and print a list.

This example imports all classes from java.util and uses both ArrayList and HashMap.

Examples

Single-type Import Example

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        System.out.println(list);
    }
}

This example imports only the ArrayList class and uses it to create and print a list.

On-demand Import Example

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Java", 1);
        System.out.println(list + " " + map);
    }
}

This example imports all classes from java.util and uses both ArrayList and HashMap.

Best Practices

Use single-type imports to keep dependencies clear.
Avoid wildcard imports to prevent namespace conflicts.
Keep import statements organized and clean.
Leverage IDE tools to manage imports efficiently.

Common Mistakes

Not importing required classes causing compilation errors.
Overusing wildcard imports leading to ambiguous class references.
Importing unused classes unnecessarily.
Confusing import statements with package declarations.

Hands-on Exercise

Practice Import Statements

Write a Java program that imports the Scanner class from java.util and uses it to read user input.

Expected output: Program reads input from the user and prints it.

Hint: Use 'import java.util.Scanner;' at the top of your file.

Compare Import Styles

Create two Java programs: one using single-type imports and another using on-demand imports. Observe and note any differences.

Expected output: Both programs compile and run correctly, but the import statements differ.

Hint: Use classes from the java.util package like ArrayList and HashMap.

Interview Questions

What is the purpose of the import statement in Java?

Interview

The import statement allows a Java program to access classes and packages from other libraries or packages without using fully qualified names.

What is the difference between single-type import and on-demand import?

Interview

Single-type import imports a specific class, while on-demand import imports all classes from a package using the wildcard '*'.

Does the import statement affect runtime performance?

Interview

No, import statements are compile-time directives and do not affect runtime performance.