Java Package
A package is simply a container that groups related types (Java classes, interfaces,
enumerations, and annotations). For example, in core Java, the ResultSet interface
belongs to the [Link] package. The package contains all the related types that are
needed for the SQL query and database connection.
If you want to use the ResultSet interface in your code, just import
the [Link] package (Importing packages will be discussed later in the article).
As mentioned earlier, packages are just containers for Java classes, interfaces and so
on. These packages help you to reserve the class namespace and create a
maintainable code.
For example, you can find two Date classes in Java. However, the rule of thumb in Java
programming is that only one unique class name is allowed in a Java project.
How did they manage to include two classes with the same name Date in JDK?
This was possible because these two Date classes belong to two different packages:
• [Link] - this is a normal Date class that can be used anywhere.
• [Link] - this is a SQL Date used for the SQL query and such.
Based on whether the package is defined by the user or not, packages are divided into
two categories:
Built-in Package
Built-in packages are existing java packages that come along with the JDK. For
example, [Link], [Link], [Link], etc. For example:
import [Link];
class ArrayListUtilization {
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<>(3);
[Link](3);
[Link](2);
[Link](1);
[Link](myList);
}
}
Output:
myList = [3, 2, 1]
The ArrayList class belongs to [Link] package. To use it, we have to import the
package first using the import statement.
import [Link];
User-defined Package
Java also allows you to create packages as per your need. These packages are called
user-defined packages.
How to define a Java package?
To define a package in Java, you use the keyword package.
package packageName;
Java uses file system directories to store packages. Let's create a Java file inside
another directory.
For example:
└── com
└── test
└── [Link]
Now, edit [Link] file, and at the beginning of the file, write the package statement as:
package [Link];
Here, any class that is declared within the test directory belongs to
the [Link] package.
Here's the code:
package [Link];
class Test {
public static void main(String[] args){
[Link]("Hello World!");
Output:
Hello World!
Here, the Test class now belongs to the [Link] package.
Package Naming convention
The package name must be unique (like a domain name). Hence, there's a convention
to create a package as a domain name, but in reverse order. For
example, [Link]
Here, each level of the package is a directory in your file system. Like this:
└── com
└── company
└── name
And, there is no limitation on how many subdirectories (package hierarchy) you can
create.
How to create a package in Intellij IDEA?
In IntelliJ IDEA, here's how you can create a package:
1. Right-click on the source folder.
2. Go to new and then package.
3. A pop-up box will appear where you can enter the package name.
Once the package is created, a similar folder structure will be created on your file
system as well. Now, you can create classes, interfaces, and so on inside the package.
How to import packages in Java?
Java has an import statement that allows you to import an entire package (as in earlier
examples), or use only certain classes and interfaces defined in the package.
The general form of import statement is:
import [Link]; // To import a certain class only
import [Link].* // To import the whole package
For example,
import [Link]; // imports only Date class
import [Link].*; // imports everything inside [Link] package
The import statement is optional in Java.
If you want to use class/interface from a certain package, you can also use its fully
qualified name, which includes its full package hierarchy.
Here is an example to import a package using the import statement.
import [Link];
class MyClass implements Date {
// body
The same task can be done using the fully qualified name as follows:
class MyClass implements [Link] {
//body
Example: Package and importing package
Suppose, you have defined a package [Link] that contains a class Helper.
package [Link];
public class Helper {
public static String getFormattedDollar (double value){
return [Link]("$%.2f", value);
}
Now, you can import Helper class from [Link] package to your
implementation class. Once you import it, the class can be referred directly by its name.
Here's how:
import [Link];
class UseHelper {
public static void main(String[] args) {
double value = 99.5;
String formattedValue = [Link](value);
[Link]("formattedValue = " + formattedValue);
Output:
formattedValue = $99.50
Here,
1. the Helper class is defined in [Link] package.
2. the Helper class is imported to a different file. The file contains UseHelper class.
3. The getFormattedDollar() method of the Helper class is called from inside
the UseHelper class.
Java import package
In Java, the import statement is written directly after the package statement (if it exists)
and before the class definition.
For example,
package [Link];
import [Link]; // only import a Class
class MyClass {
// body