Advantages and Disadvantages of Using Java Wildcard Imports

1. Overview

In this tutorial, we’ll discuss the advantages and disadvantages of using wildcard imports in Java.

2. Imports in Java

Java import statements declare the source of the names (class names, static variables, and method names) used in the code. 

As an example, let’s look at a Book class:

import java.util.Date;
import java.util.List;
import java.util.UUID;

public class Book {

    private UUID id;

    private String name;

    private Date datePublished;

    private List<String> authors;
}

Here, we need to import the two data types of Date and UUID along with the List interface as they are not available by default. So, we write three import statements to have these data types available for our class. Let’s refer to these types of imports as specific imports.

3. Java Wildcard Imports

Wildcard imports refer to importing a package instead of declaring specific class names being used from a package.

Using wildcards, we can replace the three import statements from our previous example with just one statement: 

import java.util.*;

public class Book {

    private UUID id;

    private String name;

    private Date datePublished;

    private List<String> authors;
}

This one wildcard import statement adds the entire java.util package to the search path, where the required names of UUID, Date, and List can be found.

4. Advantages of Wildcard Imports

Naturally, wildcard imports have some advantages compared to specific imports in Java. Let’s discuss the main advantages of wildcard imports in the subsections below.

4.1. Clean Code

Wildcard imports help us avoid a long list of imports in our code. Therefore, this impacts the readability of code as the reader may have to scroll a lot in every source code file before reaching the code that shows the logic. Undoubtedly, more readable code is also clean code. 

This idea is also supported in the Clean Code book by Robert C. Martin. In fact, the book recommends using wildcard imports when using multiple classes from the same source. In other words, when we import two or more classes imported from a package, it’s better to import the whole package.

4.2. Refactoring Ease

With wildcard imports, refactoring is easier. For instance, upon renaming a class, we don’t need to remove all of its specific import declarations.

Also, if we moved a class from one of our packages to another of our own packages, we don’t need to refactor any code if wildcard imports already exist in the file for both of the packages.

4.3. Loose Coupling

Wildcard imports enforce the loose-coupling approach in modern software development.

According to Robert C. Martin, the idea of having wildcard imports enforces loose-coupling. With specific imports, the class must exist in a package. However, with wildcard imports, particular classes don’t need to exist in the package. In fact, the wildcard import adds the specified package to the search path, where required class names can be searched.

Hence, wildcard-styled imports add no true dependency to the package. 

5. Disadvantages of Wildcard Imports

Wildcard imports have their disadvantages too. Next, let’s look at how wildcard imports can lead to some problems.

5.1. Class Name Conflicts

Unfortunately, conflicts can occur when a class name is found in more than one package imported through wildcard.

In this case, the compiler notices that there are two Date classes and gives an error since the Date class is found in both the java.sql and java.util packages:

import java.util.*;
import java.sql.*;

public class Library {

    private UUID id;

    private String name;

    private Time openingTime;

    private Time closingTime;

    private List<Date> datesClosed;
}

To prevent such an error, we can specify the desired source of the conflicted class.

To prevent the error in the example above, we can add a third line specifying the source of the conflicted Date class to the two existing imports:

import java.util.*;
import java.sql.*;
import java.sql.Date;

5.2. Unforeseen Class Name Conflicts

Interestingly, conflicts can also surface over time, such as when a class is added to the newer version of another package that we are using.

For instance, in Java 1.1, the List class was only found in the java.awt package. However, with Java 1.2, an interface named List was added to the java.util package.

Let’s see an example:

import java.awt.*;
import java.util.*;

public class BookView extends Frame {

    private UUID id;

    private String name;

    private Date datePublished;

    private List<String> authors;
}

Eventually, this situation can potentially cause a conflict when both java.awt and java.util packages are imported as wildcard imports. Hence, we can potentially face problems when migrating code to a newer Java version.