Package & Import

A Package in Java is a mechanism for organizing classes into a structured namespace, similar to folders. Packages prevent name collisions and control access between classes. The convention uses reverse domain names: com.skillversitas.app.

Import is used to use classes from other packages without writing the full package name. Java provides static import for importing static methods/fields directly. Wildcard imports (import java.util.*) import all classes from a package, but specific imports are recommended for readability.

Java has automatic imports for java.lang.* — classes such as String, System, Math, and Integer do not need to be imported manually. Package-private (default access) can only be accessed from classes within the same package.

Types of Imports:

• Single: import java.util.ArrayList;
• Wildcard: import java.util.*;
• Static: import static java.lang.Math.PI;

Code Example

// Import statements
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class PackageDemo {

    // Nested class
    static class Utilitas {
        static String reverse(String text) {
            return new StringBuilder(text).reverse().toString();
        }

        static boolean isPalindrome(String text) {
            String clean = text.toLowerCase().replaceAll("[^a-z0-9]", "");
            return clean.equals(reverse(clean));
        }
    }

    public static void main(String[] args) {
        // Using static imports
        System.out.println("PI = " + PI);
        System.out.println("sqrt(144) = " + sqrt(144));

        // Using a nested class
        System.out.println("Reversed: " + Utilitas.reverse("Hello"));
        System.out.println("Racecar palindrome? " + Utilitas.isPalindrome("Racecar"));

        // Using ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("Go");
        System.out.println("Languages: " + list);
    }
}

Code Explanation

1. Regular import: import java.util.ArrayList; — imports the ArrayList class so you can write it without the package prefix.
2. Static import: import static java.lang.Math.PI; — lets you write PI directly without Math.PI.
3. Nested class: Utilitas is defined inside the PackageDemo class — it can hold static methods related to the main topic.
4. Wildcard: import java.util.*; imports all classes in java.util — practical, but can cause name collisions.

Everyday Example

Creating a simple package for an app with a clean structure:

// File: com/skillversitas/model/Student.java
package com.skillversitas.model;

public record Student(String name, String studentId, double gpa) {
    public boolean withHonors() {
        return gpa >= 3.5;
    }
}

// File: com/skillversitas/util/Formatter.java
package com.skillversitas.util;

public class Formatter {
    public static String formatCurrency(double amount) {
        return String.format("$%,.0f", amount);
    }
}

// File: com/skillversitas/App.java
package com.skillversitas;

import com.skillversitas.model.Student;
import com.skillversitas.util.Formatter;

public class App {
    public static void main(String[] args) {
        Student student = new Student("John", "123456", 3.75);
        System.out.println(student.name() + " - With Honors: " + student.withHonors());
        System.out.println("Bill: " + Formatter.formatCurrency(1500000));
    }
}

Summary

Packages and imports are the foundation for organizing Java code at scale. Use reverse domain names for package names, avoid wildcard imports, and take advantage of static imports for constants you use frequently. A good package structure makes maintenance and team collaboration easier.