Packages in Java: A Guide to Modular, Maintainable Code

Packages in Java are your toolkit for organizing classes, preventing naming conflicts, and controlling access. Just like folders group related files, packages bundle related classes, interfaces, and sub-packages. In this guide, you’ll learn how to create, use, and deploy packages effectively—along with best practices to avoid common pitfalls.

What Are Packages in Java?

A package is a namespace that groups related types (classes, interfaces, enums). It serves three core purposes:

1. Prevent Naming Conflicts: Classes with the same name can exist in different packages.
2. Improve Maintainability: Organize code logically (e.g., com.company.ui, com.company.dao).
3. Control Access: Use package-private (default) access to restrict visibility.

Real-World Example:

Think of packages as department folders in an office:

• HR Package: com.company.hr (Employee, Payroll classes).
• Sales Package: com.company.sales (Invoice, Customer classes).

Types of Packages in Java

1. Built-in Packages

Predefined by Java (e.g., java.util, java.io).

import java.util.ArrayList; // Import ArrayList from java.util  
import java.time.*;         // Import all classes from java.time  

2. User-Defined Packages

Created by developers to organize project code.

package com.codersathi.model; // Declare a package  

public class User {  
    private String name;  
    // Class code  
}  

Advantages of packages in Java

The main advantages of package in Java are:

• Organization: Packages help to organize classes and interfaces into logical groups. This makes it easier to find and understand the code, and it also helps to prevent naming conflicts.
• Access control: Packages can be used to control access to classes and interfaces. This can help to protect sensitive data and to prevent unauthorized modifications to the code.
• Reusability: Packages can be reused by other developers. This can save time and effort, and it can also help to ensure that the code is consistent.
• Naming Conflicts: Package in Java prevent naming conflicts by allowing classes with the same name to coexist in different packages.

How to Create and Use Packages

Step 1: Declare a Package

Use the package keyword at the top of your file:

package com.codersathi.utils;  

public class StringUtils {  
    public static boolean isEmpty(String str) {  
        return str == null || str.trim().isEmpty();  
    }  
}  

Step 2: Compile with Directory Structure

• Save the file as com/codersathi/utils/StringUtils.java.
• Compile:

javac com/codersathi/utils/StringUtils.java  

Step 3: Import and Use

package com.codersathi.app;  
import com.codersathi.utils.StringUtils;  

public class Main {  
    public static void main(String[] args) {  
        System.out.println(StringUtils.isEmpty("")); // Output: true  
    }  
}  

How to import package in Java?

To import a package Java code, we can use the import keyword followed by the name of the package. For example, to import the com.codersathi package, we can use the following code:

import com.codersathi.*;

This will import all the classes and interfaces in the com.codersathi package. Alternatively, we can import a specific class or interface by specifying its fully qualified name, like this:

import com.codersathi.MyClass;

In Java, there are four levels of access control: private, default, protected, and public.

By using access control, we can control the visibility and accessibility of our code, preventing unintended modification or misuse. This helps to ensure the integrity and stability of our application.

Following is an example of a Java class that uses a package and access control:

package com.codersathi;

public class MyClass {
    private int privateField;
    int defaultField;
    protected int protectedField;
    public int publicField;

    private void privateMethod() {
        // code goes here
    }

    void defaultMethod() {
        // code goes here
    }

    protected void protectedMethod() {
        // code goes here
    }

    public void publicMethod() {
        // code goes here
    }
}

The class called MyClass, is part of the com.codersathi package and has four fields and four methods, each with a different level of access control.

The privateField and privateMethod can only be accessed within the MyClass class, while the defaultField and defaultMethod can be accessed within the com.codersathi package.

The protectedField and protectedMethod can be accessed within the com.codersathi package and also by subclasses of MyClass, even if they are in a different package.

Finally, the publicField and publicMethod can be accessed from anywhere.

How to compile code with package in Java?

Before going directly to the compilation syntax, first, we need to understand how the code is written with the help of the following code structure:

Let’s create a class like the one below:

package com.codersathi;
public class PackageExample{
	public String name="Coder Sathi";
}

The PackageExample class is saved under the folder com.codersathi.

Now, to compile this class go to the directory where the folder com is there.

And use the command below:

javac -d . PackageExample.java

This command should compile the class.

Now, let’s learn how to use this class in another class.

Create a main class in the default location.

import com.codersathi.*;
public class PackageDemo{
	public static void main(String[] args){
		PackageExample pe = new PackageExample();
		System.out.println(pe.name);
	}
}

Now, you can directly compile PackageDemo class using following command:

javac PackageDemo.java

Important information

If you are using an IDE like Eclipse, Netbeans or IntelliJ then you don’t need to worry about compiling these classes but while using command line then you must follow the steps given here.

Key Benefits of Using Packages

Conclusion

Packages in Java are non-negotiable for structuring professional-grade applications. By grouping related code, enforcing naming conventions, and controlling access, they lay the groundwork for scalable, maintainable systems.

FAQs