Packages in Java: How to Create/Import Package
PACKAGE in Java is a collection of classes, sub-packages, and interfaces. It helps organize your classes into a folder structure and make it easy to locate and use them. More importantly, it helps improve code reusability.
Each package in Java has its unique name and organizes its classes and interfaces into a separate namespace, or name group.
Although interfaces and classes with the same name cannot appear in the same package, they can appear in different packages. This is possible by assigning a separate namespace to each Java package.
The following video takes you through the steps of creating a package.
Click here if the video is not accessible
Let’s study package with an example. We define a class and object and later compile this it in our package p1. After compilation, we execute the code as a java package.
How to Create a package?
Creating a package is a simple task as follows
- Choose the name of the package
- Include the package command as the first line of code in your Java Source File.
- The Source file contains the classes, interfaces, etc you want to include in the package
- Compile to create the Java packages
Step 1) Consider the following package program in Java:
package p1; class c1() < public void m1()< System.out.println("m1 of c1"); >public static void main(string args[]) < c1 obj = new c1(); obj.m1(); >> 
- To put a class into a package, at the first line of code define package p1
- Create a class c1
- Defining a method m1 which prints a line.
- Defining the main method
- Creating an object of class c1
- Calling method m1
Step 2) In next step, save this file as demo.java
Step 3) In this step, we compile the file.
The compilation is completed. A class file c1 is created. However, no package is created? Next step has the solution
This command forces the compiler to create a package.
The “.” operator represents the current working directory.
Step 5) When you execute the code, it creates a package p1. When you open the java package p1 inside you will see the c1.class file.
Step 6) Compile the same file using the following code
Here “..” indicates the parent directory. In our case file will be saved in parent directory which is C Drive
File saved in parent directory when above code is executed.
Step 7) Now let’s say you want to create a sub package p2 within our existing java package p1. Then we will modify our code as
Step 8) Compile the file
As seen in below screenshot, it creates a sub-package p2 having class c1 inside the package.
Step 9) To execute the code mention the fully qualified name of the class i.e. the package name followed by the sub-package name followed by the class name –
This is how the package is executed and gives the output as “m1 of c1” from the code file.
How to Import Package
To create an object of a class (bundled in a package), in your code, you have to use its fully qualified name.
java.awt.event.actionListner object = new java.awt.event.actionListner();
But, it could become tedious to type the long dot-separated package path name for every class you want to use. Instead, it is recommended you use the import statement.
Once imported, you can use the class without mentioning its fully qualified name.
import java.awt.event.*; // * signifies all classes in this package are imported import javax.swing.JFrame // here only the JFrame class is imported //Usage JFrame f = new JFrame; // without fully qualified name.
Step 1) Copy the code into an editor.
package p3; import p1.*; //imports classes only in package p1 and NOT in the sub-package p2 class c3 < public void m3()< System.out.println("Method m3 of Class c3"); >public static void main(String args[]) < c1 obj1 = new c1(); obj1.m1(); >> Step 2) Save the file as Demo2.java. Compile the file using the command javac –d . Demo2.java
Step 3)Execute the code using the command java p3.c3
Packages – points to note:
- To avoid naming conflicts packages are given names of the domain name of the company in reverse Ex: com.guru99. com.microsoft, com.infosys etc.
- When a package name is not specified, a class is in the default package (the current working directory) and the package itself is given no name. Hence you were able to execute assignments earlier.
- While creating a package, care should be taken that the statement for creating package must be written before any other import statements
// not allowed import package p1.*; package p3; //correct syntax package p3; import package p1.*;
the java.lang package is imported by default for any class that you create in Java.
The Java API is very extensive, contains classes which can perform almost all your programming tasks right from Data Structure Manipulation to Networking. More often than not, you will be using API files in your code. You can see the API documentation here.
Java — Packages
Packages are used in Java in order to prevent naming conflicts, to control access, to make searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.
A Package can be defined as a grouping of related types (classes, interfaces, enumerations and annotations ) providing access protection and namespace management.
Some of the existing packages in Java are −
- java.lang − bundles the fundamental classes
- java.io − classes for input , output functions are bundled in this package
Programmers can define their own packages to bundle group of classes/interfaces, etc. It is a good practice to group related classes implemented by you so that a programmer can easily determine that the classes, interfaces, enumerations, and annotations are related.
Since the package creates a new namespace there won’t be any name conflicts with names in other packages. Using packages, it is easier to provide access control and it is also easier to locate the related classes.
Creating a Package
While creating a package, you should choose a name for the package and include a package statement along with that name at the top of every source file that contains the classes, interfaces, enumerations, and annotation types that you want to include in the package.
The package statement should be the first line in the source file. There can be only one package statement in each source file, and it applies to all types in the file.
If a package statement is not used then the class, interfaces, enumerations, and annotation types will be placed in the current default package.
To compile the Java programs with package statements, you have to use -d option as shown below.
javac -d Destination_folder file_name.java
Then a folder with the given package name is created in the specified destination, and the compiled class files will be placed in that folder.
Example
Let us look at an example that creates a package called animals. It is a good practice to use names of packages with lower case letters to avoid any conflicts with the names of classes and interfaces.
Following package example contains interface named animals −
/* File name : Animal.java */ package animals; interface Animal
Now, let us implement the above interface in the same package animals −
package animals; /* File name : MammalInt.java */ public class MammalInt implements Animal < public void eat() < System.out.println("Mammal eats"); >public void travel() < System.out.println("Mammal travels"); >public int noOfLegs() < return 0; >public static void main(String args[]) < MammalInt m = new MammalInt(); m.eat(); m.travel(); >> Now compile the java files as shown below −
$ javac -d . Animal.java $ javac -d . MammalInt.java
Now a package/folder with the name animals will be created in the current directory and these class files will be placed in it as shown below.
You can execute the class file within the package and get the result as shown below.
Mammal eats Mammal travels
The import Keyword
If a class wants to use another class in the same package, the package name need not be used. Classes in the same package find each other without any special syntax.
Example
Here, a class named Boss is added to the payroll package that already contains Employee. The Boss can then refer to the Employee class without using the payroll prefix, as demonstrated by the following Boss class.
package payroll; public class Boss < public void payEmployee(Employee e) < e.mailCheck(); >>
What happens if the Employee class is not in the payroll package? The Boss class must then use one of the following techniques for referring to a class in a different package.
Note − A class file can contain any number of import statements. The import statements must appear after the package statement and before the class declaration.
The Directory Structure of Packages
Two major results occur when a class is placed in a package −
- The name of the package becomes a part of the name of the class, as we just discussed in the previous section.
- The name of the package must match the directory structure where the corresponding bytecode resides.
Here is simple way of managing your files in Java −
Put the source code for a class, interface, enumeration, or annotation type in a text file whose name is the simple name of the type and whose extension is .java.
// File Name : Car.java package vehicle; public class Car < // Class implementation. >
Now, put the source file in a directory whose name reflects the name of the package to which the class belongs −
Now, the qualified class name and pathname would be as follows −
In general, a company uses its reversed Internet domain name for its package names.
Example − A company’s Internet domain name is apple.com, then all its package names would start with com.apple. Each component of the package name corresponds to a subdirectory.
Example − The company had a com.apple.computers package that contained a Dell.java source file, it would be contained in a series of subdirectories like this −
. \com\apple\computers\Dell.java
At the time of compilation, the compiler creates a different output file for each class, interface and enumeration defined in it. The base name of the output file is the name of the type, and its extension is .class.
// File Name: Dell.java package com.apple.computers; public class Dell < >class Ups
Now, compile this file as follows using -d option −
The files will be compiled as follows −
.\com\apple\computers\Dell.class .\com\apple\computers\Ups.class
You can import all the classes or interfaces defined in \com\apple\computers\ as follows −
Like the .java source files, the compiled .class files should be in a series of directories that reflect the package name. However, the path to the .class files does not have to be the same as the path to the .java source files. You can arrange your source and class directories separately, as −
\sources\com\apple\computers\Dell.java \classes\com\apple\computers\Dell.class
By doing this, it is possible to give access to the classes directory to other programmers without revealing your sources. You also need to manage source and class files in this manner so that the compiler and the Java Virtual Machine (JVM) can find all the types your program uses.
The full path to the classes directory, \classes, is called the class path, and is set with the CLASSPATH system variable. Both the compiler and the JVM construct the path to your .class files by adding the package name to the class path.
Say \classes is the class path, and the package name is com.apple.computers, then the compiler and JVM will look for .class files in \classes\com\apple\computers.
A class path may include several paths. Multiple paths should be separated by a semicolon (Windows) or colon (Unix). By default, the compiler and the JVM search the current directory and the JAR file containing the Java platform classes so that these directories are automatically in the class path.
Set CLASSPATH System Variable
To display the current CLASSPATH variable, use the following commands in Windows and UNIX (Bourne shell) −
To delete the current contents of the CLASSPATH variable, use −
To set the CLASSPATH variable −
- In Windows → set CLASSPATH = C:\users\jack\java\classes
- In UNIX → % CLASSPATH = /home/jack/java/classes; export CLASSPATH