Java packages are used to organize classes and interfaces into namespaces. Packages help to avoid naming conflicts and make it easier to find and reuse code. In this section, I'll introduce you to the basics of Java packages.
What is a Package?
A package is a group of related classes and interfaces. Packages are used to organize code and prevent naming conflicts. A package is defined using the package keyword followed by the package name.
Here's an example of how to define a package in Java: package com.example.mypackage;
In this example, we're defining a package called com.example.mypackage.
Package Structure
Java packages follow a hierarchical structure. The package name is divided into segments using the dot (.) separator. The first segment is the top-level package, followed by sub-packages, and so on. For example, the package name com.example.mypackage has three segments: **com**, **example**, and **mypackage**. The top-level package is com, and **mypackage** is a sub-package of example, which is a sub-package of com.
Package Declarations
To declare that a class belongs to a package, you use the package keyword followed by the package name at the beginning of the Java source file. Here's an example of how to declare a package for a class:
package com.example.mypackage;
public class MyClass {
// class code goes here}
In the above example, we're declaring that the MyClass class belongs to the com.example.mypackage package.
Importing Packages
To use classes or interfaces from other packages, you need to import them into your code. You can import individual classes or entire`` packages using the import keyword. Here's an example of how to import a class from a package:
import com.example.mypackage.MyClass;
public class MyOtherClass {
MyClass myObject = new MyClass();}
In the above example, we're importing the MyClass class from the com.example.mypackage package and creating a new instance of it.
Creating and Using Packages
To create your own package, you need to create a directory hierarchy that corresponds to the package name. For example, to create a package called **com.example.mypackage**, you would create the following directory structure:
com/
|-example/
|-mypackage/
|- MyClass.java
In the above example, we're creating a directory called com at the root of the project directory. Inside com, we're creating a directory called example, and inside example, we're creating a directory called mypackage.
Finally, we're creating a Java source file called MyClass.java inside the mypackage directory. The contents of MyClass.java would look something like this:
package com.example.mypackage;
public class MyClass {
public static void main(String\[\] args){
System.out.println("Package Example");
}
}
How to compile a Java package
Compile your Java files using javac. Make sure to include the appropriate directory structure in the compilation command. For example, if your source files are in the src directory, you can compile them with the following command:
javac -d . src/com/example/mypackage/*.java
Here, -d specifies the destination directory for compiled class files. The ‘.’ indicates that the class files should be placed in the current directory. you might be asking why we need -d to compile the above java class, as we can compile the java file using only by javac command without -d flag.
So I will take 2 minutes to explain the reason behind it.
The -d option in the javac command is used to specify the destination directory for the compiled class files. When you compile Java files, the compiler generates corresponding class files. If you don't specify the destination directory using -d, the compiled class files will be placed in the same directory as the source files by default.
However, when you're organizing your code into packages, it's often desirable to keep the compiled class files separate from the source files. This helps maintain a clean project structure and makes it easier to manage your code. By specifying a destination directory using -d, you can ensure that the compiled class files are placed in the appropriate package directory structure.
In the example provided earlier, the -d option is used to specify that the compiled class files should be placed in the current directory (.) while preserving the package structure. This means that the javac command will create the necessary subdirectories (com/example/mypackage/) and place the compiled MyClass.class file inside the com/example/mypackage directory. So, the -d option is essential for organizing compiled class files into packages and maintaining a clean project structure. Now as we have compiled the java file in a package, it is ready to be used. To use the MyClass class from another part of the program, you would import it like this:
import com.example.mypackage.MyClass;
public class MyOtherClass {
MyClass myObject = new MyClass();
}
Project time
Let’s use our learnings so far to create a small project. Let's create a simple Java project for managing notes to highlight package concepts in java. In this project, we'll have a notes package containing classes to create, read, update, and delete notes. Let’s start with the project directory which is as shown below:
notes_project/
├── src/
│ └── com/
│ └── yourcompany/
│ └── notes/
│ ├── Note.java
│ └── NotesManager.java
└── Main.java
Let’s create the above directory structure using the command line; mkdir -p notes_project/src/com/yourcompany/notes
With the above command, our required directory structure will be ready, after which we will try to understand the functionality for the different Java files present in the above project directory
Functionality:
- Note.java: Represents a single note with fields for title and content.
- NotesManager.java: Contains methods for managing notes, such as adding, reading, updating, and deleting notes.
- Main.java: Main class to demonstrate how to use the notes package.
As we are clear with the functionality of our project let’s jump to the coding part , we will start with the Note.java as shown below: public class MyClass {
notes_project/src/com/yourcompany/notes/Note.java
package com.yourcompany.notes;
public class Note {
private String title;
private String content;
public Note(String title, String content) {
this.title = title;
this.content = content;
}
public String getTitle() {
return title;
}
public String getContent() {
return content;
}
@Override
public String toString() {
return "Title: " + title + "\\nContent: " + content;
}
}
After implementing the Note.java we will now write the NotesManager class as well
// notes_project/src/com/yourcompany/notes/NotesManager.java
package com.yourcompany.notes;
import java.util.ArrayList;
import java.util.List;
public class NotesManager {
private List<Note> notes;
public NotesManager() {
notes = new ArrayList<>();
}
public void addNote(Note note) {
notes.add(note);
}
public List<Note> getAllNotes() {
return notes;
}
// You can implement additional methods like update and delete here
}
As you can see above both Notes.java & NotesManager.java exist in the same package ie com.yourcompany.notes Now we will be using the above package in our Main.java file as shown below:
// notes_project/Main.java
import com.yourcompany.notes.
public class Main {
public static void main(String\[\] args) {
NotesManager manager = new NotesManager();
// Creating some sample notes
Note note1 = new Note("Shopping List", "1. Milk\\n2. Bread\\n3. Eggs");
Note note2 = new Note("To-Do List", "1. Finish project\\n2. Study for exam");
// Adding notes to the manager
manager.addNote(note1);
manager.addNote(note2);
// Displaying all notes
System.out.println("All Notes:");
for (Note note : manager.getAllNotes()) {
System.out.println(note);
System.out.println("-------------");
}
}
}
As you can see we have imported everything from the package import com.yourcompany.notes so we have used * ie import com.yourcompany.notes.*; If you want to import a specific file from the package then you need to use the below syntax
import com.yourcompany.notes.Note;
import com.yourcompany.notes.NotesManager;
Let’s understand in more details what we have written in Main.java
-
In the Main class, we create two Note objects: note1 and note2, representing different notes.
-
Each Note object contains a title and content, which we pass as arguments to its constructor.
After that we will be adding notes to the NotesManager for that
-
We create an instance of the NotesManager class named manager.
-
We use the addNote() method of the NotesManager class to add each Note object to the list of notes managed by the NotesManager.
Finally we will display the output
-
We iterate over all the notes managed by the NotesManager using the getAllNotes() method.
-
For each Note object, we print its title and content to the console using its toString() method.
-
We print a divider after each note to visually separate them.
Awesome!! Now we are ready with our project, let’s compile the project to run it . From root directory of your project hit the below command
javac -d . notes_project/src/com/yourcompany/notes/*.java notes_project/Main.java
Let’s understand the above command step by step:
1. javac: This is the Java compiler command.
2. -d .: This option specifies the destination directory for the compiled class files. In this case, . represents the current directory. So, the compiled class files will be placed in the current directory.
3. notes_project/src/com/yourcompany/notes/*.java: This part of the command specifies the source files to be compiled. It uses a wildcard *.java to indicate all .java files in the notes_project/src/com/yourcompany/notes/ directory. So, all Java files within this directory will be compiled.
4. notes_project/Main.java: This is another source file to be compiled, specifically the Main.java file located in the notes_project directory. So after the compilation process, we will get our Main.class file inside the root folder as shown below.
Let's see the above directory structure in more detail
Now let’s run our project by using the below command from the project root directory
java-projects> java Main
We will get output something like below:
Let’s understand our output shown above:
-
The output consists of the titles and contents of the two notes created earlier.
-
Each note is displayed with its title followed by its content.
-
There is a visual separator (------------) between each note to improve readability.
Note: This is a basic project demonstrating how to use packages in Java to organize classes related to managing notes. You can expand upon this project by adding more functionality such as updating and deleting notes, implementing persistence with file I/O or a database, creating a graphical user interface (GUI), etc.
Conclusion
Java packages are essential for organizing code and avoiding naming conflicts. By using packages, you can create reusable code that can be easily found and reused in different parts of your program. If you like this article then feel free to follow me here to enjoy many more articles like this.