Creating and Using Packages in Java

Java is a powerful programming language that supports object-oriented concepts such as classes, objects, inheritance, interfaces, and packages. As Java programs grow larger, managing many classes becomes difficult. To solve this problem, Java provides a feature called packages.

A package in Java is a namespace that groups related classes and interfaces together. Packages help organize large programs into smaller, manageable units and avoid naming conflicts between classes.

For students studying the ITI COPA (Computer Operator and Programming Assistant) trade, understanding packages is important because they are widely used in Java programming and software development.

What is a Package?

A package is a collection of related classes and interfaces grouped together under a common name.

Packages are used to organize Java classes in a structured way. They work similarly to folders or directories in a computer file system.

For example, Java provides many built-in packages such as:

• java.lang
• java.util
• java.io
• java.net

These packages contain useful classes that programmers can use in their programs.

Advantages of Packages

Packages provide several benefits in Java programming.

• Organize large programs into smaller units
• Avoid naming conflicts between classes
• Improve code readability and maintenance
• Support access protection

Because of these advantages, packages are widely used in large software systems.

Types of Packages in Java

Java packages are mainly divided into two types:

• Built-in packages
• User-defined packages

Built-in Packages

Built-in packages are packages that come with the Java standard library. They contain predefined classes that programmers can use directly.

Examples include:

• java.lang – Contains fundamental classes such as String and Math.
• java.util – Contains utility classes like Scanner and ArrayList.
• java.io – Contains classes for input and output operations.

User-Defined Packages

User-defined packages are packages created by programmers to organize their own classes and interfaces.

These packages are useful when developing large applications.

Creating a Package in Java

To create a package in Java, the package keyword is used at the beginning of the program.

Syntax

package packageName;

Example

package mypackage;

public class Example {

    public void display() {
        System.out.println("This is a user-defined package");
    }

}

In this example, the class Example belongs to the package called mypackage.

Compiling a Package

To compile a Java program with a package, the following command is used:

javac -d . Example.java

The -d option tells the compiler to create the necessary directory structure for the package.

Using a Package

Once a package is created, it can be used in other programs using the import keyword.

Syntax

import packageName.className;

Example

import mypackage.Example;

public class TestPackage {

    public static void main(String[] args) {

        Example obj = new Example();
        obj.display();

    }

}

This program imports the Example class from the mypackage package.

Importing Entire Package

Instead of importing a single class, we can import all classes from a package.

import java.util.*;

This statement imports all classes from the java.util package.

Accessing Package Classes

Classes inside a package can be accessed using either:

• Import statement
• Fully qualified class name

Example Using Fully Qualified Name

public class Test {

    public static void main(String[] args) {

        java.util.Scanner sc = new java.util.Scanner(System.in);

    }

}

Here the Scanner class is accessed using its full package name.

Subpackages in Java

Java also supports subpackages, which are packages inside other packages.

Example

package com.company.project;

This package contains multiple levels:

• com
• company
• project

Subpackages help organize large applications more efficiently.

Access Protection in Packages

Java provides access modifiers that control the visibility of classes and members within packages.

• public – Accessible from anywhere
• protected – Accessible within the package and subclasses
• default – Accessible only within the package
• private – Accessible only within the class

These access modifiers help maintain security and data protection in Java programs.

Example Program Using Package

package calculator;

public class Addition {

    public int add(int a, int b) {
        return a + b;
    }

}

Main Program

import calculator.Addition;

public class Test {

    public static void main(String[] args) {

        Addition a = new Addition();
        System.out.println(a.add(10,5));

    }

}

Output:

15

This example demonstrates how a class from one package can be used in another program.

Applications of Packages

Packages are widely used in software development.

• Organizing large projects
• Developing reusable libraries
• Building frameworks
• Managing enterprise applications

Most professional Java applications use packages to maintain a clear project structure.

Importance for ITI COPA Students

For students studying the ITI COPA trade, learning packages is important because it helps manage large Java programs and improves program organization.

Understanding packages also prepares students for advanced topics such as Java frameworks, modular programming, and large-scale software development.

Conclusion

Packages are an essential feature of Java that help organize classes and interfaces into logical groups. They improve code structure, prevent naming conflicts, and make programs easier to maintain.

Java supports both built-in packages and user-defined packages. By creating and using packages, programmers can develop well-structured and scalable applications.

For ITI COPA students, mastering packages provides a strong foundation for professional Java programming and large-scale software development.