Packages in Java are used to organize classes and interfaces into namespaces, making code more modular, reusable, and maintainable. Here's a comprehensive guide to creating and using custom packages.

1. Basic Package Structure

Directory Structure

project-root/
├── com/
│   └── mycompany/
│       └── util/
│           ├── MathHelper.java
│           └── StringHelper.java
└── Main.java

Creating a Simple Package

com/mycompany/util/MathHelper.java

package com.mycompany.util;
public class MathHelper {
public static int add(int a, int b) {
return a + b;
}
public static int multiply(int a, int b) {
return a * b;
}
public static boolean isEven(int number) {
return number % 2 == 0;
}
}

com/mycompany/util/StringHelper.java

package com.mycompany.util;
public class StringHelper {
public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}
public static boolean isPalindrome(String str) {
String cleaned = str.replaceAll("\\s+", "").toLowerCase();
return cleaned.equals(reverse(cleaned));
}
}

2. Using Packages

Importing Specific Classes

import com.mycompany.util.MathHelper;
import com.mycompany.util.StringHelper;
public class Main {
public static void main(String[] args) {
int sum = MathHelper.add(5, 3);
String reversed = StringHelper.reverse("Hello");
System.out.println("Sum: " + sum);
System.out.println("Reversed: " + reversed);
}
}

Importing Entire Package

import com.mycompany.util.*;
public class Main {
public static void main(String[] args) {
System.out.println("Is 10 even? " + MathHelper.isEven(10));
System.out.println("Is 'radar' palindrome? " + StringHelper.isPalindrome("radar"));
}
}

Using Fully Qualified Names (Without Import)

public class Main {
public static void main(String[] args) {
int result = com.mycompany.util.MathHelper.multiply(4, 5);
System.out.println("Multiplication result: " + result);
}
}

3. Package with Access Modifiers

com/mycompany/model/Person.java

package com.mycompany.model;
public class Person {
private String name;
private int age;
// Package-private constructor
Person(String name, int age) {
this.name = name;
this.age = age;
}
// Public factory method
public static Person createPerson(String name, int age) {
return new Person(name, age);
}
// Public getters
public String getName() {
return name;
}
public int getAge() {
return age;
}
// Package-private method
void setAge(int age) {
this.age = age;
}
}

com/mycompany/model/Employee.java (same package)

package com.mycompany.model;
public class Employee {
public void demoAccess() {
// Can access package-private members within same package
Person person = new Person("John", 25); // Constructor is accessible
person.setAge(30); // Method is accessible
}
}

4. Subpackages

Directory Structure

project-root/
├── com/
│   └── mycompany/
│       ├── util/
│       │   ├── MathHelper.java
│       │   └── StringHelper.java
│       └── service/
│           ├── UserService.java
│           └── ProductService.java
└── Main.java

com/mycompany/service/UserService.java

package com.mycompany.service;
import com.mycompany.util.StringHelper; // Import from different subpackage
public class UserService {
public void processUsername(String username) {
String formattedName = StringHelper.reverse(username);
System.out.println("Formatted username: " + formattedName);
}
public static void displayServiceInfo() {
System.out.println("User Service - manages user operations");
}
}

5. Compiling and Running

Command Line Compilation

# Compile all Java files
javac com/mycompany/util/*.java com/mycompany/service/*.java Main.java
# Or compile from project root
javac -d . com/mycompany/util/MathHelper.java
javac -d . com/mycompany/util/StringHelper.java
javac -d . com/mycompany/service/UserService.java
javac -d . Main.java
# Run the application
java Main

Using CLASSPATH

# Set CLASSPATH and compile
export CLASSPATH=/path/to/project-root
javac com/mycompany/util/MathHelper.java
javac Main.java
java Main

6. Advanced Package Example

Complete Example Structure

bank-app/
├── com/
│   └── bank/
│       ├── model/
│       │   ├── Account.java
│       │   └── Customer.java
│       ├── service/
│       │   ├── AccountService.java
│       │   └── TransactionService.java
│       └── util/
│           └── Validator.java
└── BankApp.java

com/bank/model/Account.java

package com.bank.model;
public class Account {
private String accountNumber;
private double balance;
private Customer customer;
public Account(String accountNumber, Customer customer) {
this.accountNumber = accountNumber;
this.customer = customer;
this.balance = 0.0;
}
// Getters and setters
public String getAccountNumber() { return accountNumber; }
public double getBalance() { return balance; }
public Customer getCustomer() { return customer; }
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public boolean withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
return true;
}
return false;
}
}

com/bank/service/AccountService.java

package com.bank.service;
import com.bank.model.Account;
import com.bank.util.Validator;
public class AccountService {
public static Account createAccount(String accountNumber, String customerName) {
if (!Validator.isValidAccountNumber(accountNumber)) {
throw new IllegalArgumentException("Invalid account number");
}
return new Account(accountNumber, customerName);
}
public static void transfer(Account from, Account to, double amount) {
if (from.withdraw(amount)) {
to.deposit(amount);
System.out.println("Transfer successful: $" + amount);
} else {
System.out.println("Transfer failed: Insufficient funds");
}
}
}

com/bank/util/Validator.java

package com.bank.util;
public class Validator {
public static boolean isValidAccountNumber(String accountNumber) {
return accountNumber != null && 
accountNumber.matches("\\d{8,12}") && 
!accountNumber.startsWith("0");
}
public static boolean isValidAmount(double amount) {
return amount > 0;
}
}

BankApp.java

import com.bank.model.Account;
import com.bank.service.AccountService;
public class BankApp {
public static void main(String[] args) {
try {
Account acc1 = AccountService.createAccount("12345678", "John Doe");
Account acc2 = AccountService.createAccount("87654321", "Jane Smith");
acc1.deposit(1000);
acc2.deposit(500);
AccountService.transfer(acc1, acc2, 300);
System.out.println("Account 1 balance: $" + acc1.getBalance());
System.out.println("Account 2 balance: $" + acc2.getBalance());
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
}

7. Best Practices

1. Use reverse domain name convention: com.companyname.project.module
2. Keep packages focused: Each package should have a single responsibility
3. Use meaningful names: Avoid generic names like util, common
4. Follow Java naming conventions: Use lowercase for package names
5. Minimize package dependencies: Reduce coupling between packages
6. Use access modifiers appropriately:

• public: Accessible from anywhere
• protected: Accessible within package and subclasses
• default (package-private): Accessible only within package
• private: Accessible only within class

8. Common Issues and Solutions

Class Not Found

// Error: cannot find symbol
// Solution: Check package declaration and imports
import com.mycompany.util.MathHelper;

Compilation Issues

# Compile with proper directory structure
javac -d . com/mycompany/util/MathHelper.java
# Run from correct directory with proper package structure
java com.mycompany.Main

This comprehensive guide covers creating, organizing, and using custom packages in Java, helping you build well-structured, maintainable applications.