Java Packages – Built-in & User-defined Packages in Java

⏱️ 22 min read • Beginner Level • Lesson 53

Packages in Java group related classes, interfaces, enums, records, annotations, and sub-packages under meaningful namespaces.

Packages help organize large applications, reduce class-name conflicts, support access control, and make code easier to locate and maintain. In this lesson, you will create a package, compile it, import its classes, use fully qualified names, work with static imports, and understand package naming rules.

What is a Package in Java?

A package is a named namespace used to organize related Java types. A type's package becomes part of its complete identity. For example, java.util.Date and java.sql.Date are different classes even though both have the simple name Date.

Real-World Analogy

Imagine a company with separate departments such as Accounts, Human Resources, and Development. Each department groups people who perform related work. Java packages organize classes in a similar way.

Why Use Packages?

Java Package Syntax

Declare a package with the package keyword. The declaration must be the first non-comment statement in the source file.

package packageName;

class ClassName {
    // fields, constructors, and methods
}

Types of Java Packages

Common Built-in Java Packages

Create a User-defined Package

The following example creates a reusable public class in com.prowessapps.demo and then uses it from another class.

Step 1: Create the Package Class

package com.prowessapps.demo;

public class GreetingService {
    public void greet(String name) {
        System.out.println("Welcome, " + name + "!");
    }
}

Step 2: Import and Use the Package Class

import com.prowessapps.demo.GreetingService;

class PackageTest {
    public static void main(String[] args) {
        GreetingService service = new GreetingService();
        service.greet("Ayan");
    }
}

Output:

Welcome, Ayan!

Compile and Run a Java Package

Run these commands from the project directory containing GreetingService.java and PackageTest.java. The -d option tells javac where to create the package directory structure for compiled classes.

javac -d . GreetingService.java PackageTest.java

java PackageTest

Package Folder Structure

Java tools normally organize source and compiled files in directories that mirror the package components.

src/
└── com/
    └── prowessapps/
        └── demo/
            └── GreetingService.java

out/
└── com/
    └── prowessapps/
        └── demo/
            └── GreetingService.class

Fully Qualified Class Name

A fully qualified class name combines the package name and class name. It uniquely identifies a type and can be used without an import statement.

class FullyQualifiedNameExample {
    public static void main(String[] args) {
        java.util.ArrayList<String> languages =
                new java.util.ArrayList<>();

        languages.add("Java");
        languages.add("Python");

        System.out.println(languages);
    }
}

Output:

[Java, Python]

Import Statement

An import declaration lets you refer to an accessible type by its simple name instead of repeating its fully qualified name.

import java.util.ArrayList;

class ImportExample {
    public static void main(String[] args) {
        ArrayList<String> languages = new ArrayList<>();

        languages.add("Java");
        languages.add("Python");

        System.out.println(languages);
    }
}

Output:

[Java, Python]

Types of Import Declarations

Static Import

Static import lets you use accessible static methods and constants without repeatedly writing the declaring class name.

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

class StaticImportExample {
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(sqrt(25));
    }
}

Output:

3.141592653589793
5.0

Unnamed Package

If a source file has no package declaration, its top-level types belong to an unnamed package, informally called the default package.

Java Package Naming Conventions

Packages and Access Control

Packages are part of Java's access-control system. Members with default access are available only inside the same package. Protected members are available in the same package and also through inheritance under Java's protected-access rules.

Table Summary

Tricky Cases

1. Can the package declaration appear after an import?

2. Does import java.util.*; include sub-packages?

3. What if two packages contain a class with the same name?

Use the fully qualified class name for at least one of the conflicting types.

class SameClassNameExample {
    public static void main(String[] args) {
        java.util.Date utilDate = new java.util.Date();
        java.sql.Date sqlDate =
                new java.sql.Date(System.currentTimeMillis());

        System.out.println(utilDate.getClass().getName());
        System.out.println(sqlDate.getClass().getName());
    }
}

Output:

java.util.Date
java.sql.Date

4. Is a sub-package automatically part of its parent package?

5. Can one source file contain multiple package declarations?

Common Mistakes

Interview Questions ⭐

Test your understanding with a quick quiz

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

import static java.lang.Math.sqrt;

class Test {
    public static void main(String[] args) {
        System.out.println(sqrt(25));
    }
}

Great job! Continue learning Java OOP step by step.