How to Create a Package in Java?

Packages in Java

Before learning how to create a package in Java, let's briefly discuss what are packages in Java. A package serves as a structured mechanism to organize and manage a collection of related classes, sub-packages, and interfaces. With packages, developers can logically group classes that share a common purpose or functionality. This grouping enhances code reusability and minimizes naming conflicts. By placing related classes within a package, developers can better comprehend the relationships between various components of a project.

Using packages involves employing the "import" statement to access classes from other packages. This way, you can reuse classes and functionalities without having to rewrite code. Some classes within a package might be designed for external use and are thus exposed, while others can remain hidden for internal purposes, contributing to better code encapsulation. Java packages also offer a hierarchical structure.

In Java, there are two types of packages:

1. User-defined Package:
   Developers can create their own packages to organize their code. This involves grouping related classes into a designated package and utilizing them across various parts of the project.
2. Built-in Packages:
   Java provides built-in packages through its Application Programming Interface (API). These packages, such as "java.swing," "java.util," and "java.io," offer a wide range of pre-built classes and functionalities that developers can readily incorporate into their applications.

Different Ways to Create a Package in Java

This is how to create a package in Java.

1. Choose a Package Name:
   Select a name for your package, adhering to the reverse domain name convention. For instance, "com.example.myapp."

2. Use the package Statement:
   In your source code's first line, include the chosen package name.

   Code:

3. Include Elements in the Package:
   Define classes, interfaces, etc., within the package's directory structure on your file system, reflecting the chosen package name.

   Code:

By following these steps, you establish a well-organized code structure, enhancing code management and modularity.

Examples

Example 1:

Consider the following example where we create a package named com.mycompany.mypackage and include a class within it.

1. Create the Package and Class Files: Code:

2. Open a terminal and navigate to the directory containing the MyClass.java file.
3. Compile the Java code to create the .class file

Code:

This generates the MyClass.class file.

4. After compiling the MyClass.java file, you can create the package directory structure using the -d option along with javac:

Code:

This command will place the MyClass.class file inside the appropriate package directory (com/mycompany/mypackage) within the current directory.

5. Run the compiled program using the following command.

Code:

This command executes the MyClass class from the com.mycompany.mypackage package and produces the output.

Output:

Explanation:

In this example, we've created a package named com.mycompany.mypackage and placed the MyClass class within it. Following the steps you provided, we've compiled and executed the program successfully.

Example 2:

Code:

To achieve the intended output as shown above, follow the specified commands.

1. This command will generate a class file.

Code:

2. So This Command Will Create a New Folder Called example.

Code:

In example, ExampleClass.java & ExampleClass.class files should be present

Example 3:

We will now try to access data from another program.

Code:

The following commands are executed to produce the output. Initially, a file named 'abc.java' will be generated outside the 'example' directory.

Code:

The command above produces a non-runnable class file. So we need an additional command to transform the non-runnable class file into an executable running file.

Code:

Output: After the above command is executed, the following output is generated on the terminal.

Naming Convention for Java Packages

The naming convention for Java packages follows the reverse domain name format, which ensures uniqueness and provides a structured way to categorize related code. Here's how the naming convention works:

1. Domain Name Reversal:
   Start with your organization's domain name in reverse order. For example, if your domain is example.com, you would reverse it to com.example.
2. Project-Specific Prefix:
   After the reversed domain name, you can add a project-specific prefix. This prefix should be in lowercase and should represent the project or module within your organization. For instance, if you're working on a project called "myapp," you would add it as the next part of the package name: com.example.myapp.
3. Sub-Packages:
   If your project is complex and requires further subdivision, you can create sub-packages under the main package. These sub-packages should be named descriptively to reflect their content. For instance, if your "myapp" project has a module for user management, you could have a sub-package like com.example.myapp.usermanagement.
4. Class Names:
   Finally, your class names should be meaningful and follow standard Java naming conventions (CamelCase with a capital letter for each word).

Importing a Package in Java

Importing a package in Java allows you to access classes and other resources from that package in your code without having to provide the fully qualified class name every time. Here's how importing a package works, along with syntax and examples:

Syntax:

where

• packageName is the name of the package you want to import.
• ClassName is the specific class within the package that you want to use.

Example:

Suppose you have a package named com.example.myapp.usermanagement containing a class User.

Code:

To use the User class in another class within a different package, you would import it as follows.

Code:

Explanation:

In this example, we are importing the User class from the com.example.myapp.usermanagement package. This allows us to refer to the class directly by its simple name (User) instead of its fully qualified name (com.example.myapp.usermanagement.User).

You can also use the wildcard * to import all classes from a package, but be cautious as it might lead to naming conflicts or unnecessary dependencies.

Code:

However, it is a good practice to import only the specific classes you need to avoid cluttering your code with unnecessary imports and to prevent potential conflicts.