Open In App

Packages In Java

Last Updated : 24 Apr, 2024
Like Article

Package in Java is a mechanism to encapsulate a group of classes, sub packages and interfaces. Packages are used for:

  • Preventing naming conflicts. For example there can be two classes with name Employee in two packages, college.staff.cse.Employee and
  • Making searching/locating and usage of classes, interfaces, enumerations and annotations easier
  • Providing controlled access: protected and default have package level access control. A protected member is accessible by classes in the same package and its subclasses. A default member (without any access specifier) is accessible by classes in the same package only.
  • Packages can be considered as data encapsulation (or data-hiding).

All we need to do is put related classes into packages. After that, we can simply write an import class from existing packages and use it in our program. A package is a container of a group of related classes where some of the classes are accessible are exposed and others are kept for internal purpose. We can reuse existing classes from the packages as many time as we need it in our program.

How packages work?

Package names and directory structure are closely related. For example if a package name is college.staff.cse, then there are three directories, college, staffand cse such that cse is present in staff and staff is present inside college. Also, the directory college is accessible through CLASSPATH variable, i.e., path of parent directory of college is present in CLASSPATH. The idea is to make sure that classes are easy to locate.

Package naming conventions : Packages are named in reverse order of domain names, i.e., org.geeksforgeeks.practice. For example, in a college, the recommended convention is,,, etc.

Adding a class to a Package : We can add more classes to a created package by using package name at the top of the program and saving it in the package directory. We need a new java file to define a public class, otherwise we can add the new class to an existing .java file and recompile it.

Subpackages: Packages that are inside another package are the subpackages. These are not imported by default, they have to imported explicitly. Also, members of a subpackage have no access privileges, i.e., they are considered as different package for protected and default access specifiers.

Example :

import java.util.*;

util is a subpackage created inside java package.  

Accessing classes inside a package

Consider following two statements :

// import the Vector class from util package.
import java.util.vector; 

// import all the classes from util package
import java.util.*; 
  • First Statement is used to import Vector class from util package which is contained inside java.
  • Second statement imports all the classes from util package.
// All the classes and interfaces of this package
// will be accessible but not subpackages.
import package.*;

// Only mentioned class of this package will be accessible.
import package.classname;

// Class name is generally used when two packages have the same
// class name. For example in below code both packages have
// date class so using a fully qualified name to avoid conflict
import java.util.Date;
import my.package.Date;
// Java program to demonstrate accessing of members when
// corresponding classes are imported and not imported.
import java.util.Vector;
public class ImportDemo
   public ImportDemo()
      // java.util.Vector is imported, hence we are
      // able to access directly in our code.
      Vector newVector = new Vector();
      // java.util.ArrayList is not imported, hence 
      // we were referring to it using the complete 
      // package.
      java.util.ArrayList newList = new java.util.ArrayList();
   public static void main(String arg[])
      new ImportDemo();

Types of packages:


Built-in Packages

These packages consist of a large number of classes which are a part of Java API.Some of the commonly used built-in packages are:

  1. java.lang: Contains language support classes(e.g classes which defines primitive data types, math operations). This package is automatically imported.
  2. Contains classes for supporting input / output operations.
  3.  java.util: Contains utility classes which implement data structures like Linked List, Dictionary and support ; for Date / Time operations.
  4.  java.applet: Contains classes for creating Applets.
  5.  java.awt: Contain classes for implementing the components for graphical user interfaces (like button , ;menus etc). 6)
  6. Contain classes for supporting networking operations.

User-defined packages: These are the packages that are defined by the user. First we create a directory myPackage (name should be same as the name of the package). Then create the MyClass inside the directory with the first statement being the package names.

// Name of the package must be same as the directory
// under which this file is saved
package myPackage;

public class MyClass
    public void getNames(String s)

Now we can use the MyClass class in our program.

/* import 'MyClass' class from 'names' myPackage */
import myPackage.MyClass;

public class PrintName 
   public static void main(String args[]) 
      // Initializing the String variable 
      // with a value 
      String name = "GeeksforGeeks";
      // Creating an instance of class MyClass in 
      // the package.
      MyClass obj = new MyClass();

Note : must be saved inside the myPackage directory since it is a part of the package.  

Using Static Import

Static import is a feature introduced in Java programming language ( versions 5 and above ) that allows members ( fields and methods ) defined in a class as public static to be used in Java code without specifying the class in which the field is defined. Following program demonstrates static import:

// Note static keyword after import.
import static java.lang.System.*;

class StaticImportDemo {
    public static void main(String args[])
        // We don't need to use 'System.out'
        // as imported using static.



Handling name conflicts

The only time we need to pay attention to packages is when we have a name conflict . For example both, java.util and java.sql packages have a class named Date. So if we import both packages in program as follows:

import java.util.*;
import java.sql.*;

//And then use Date class, then we will get a compile-time error :

Date today ; //ERROR-- java.util.Date or java.sql.Date?

The compiler will not be able to figure out which Date class do we want. This problem can be solved by using a specific import statement:

import java.util.Date;
import java.sql.*;

If we need both Date classes then, we need to use a full package name every time we declare a new object of that class. For Example:

java.util.Date deadLine = new java.util.Date();
java.sql.Date today = new java.sql.Date();

Directory structure

The package name is closely associated with the directory structure used to store the classes. The classes (and other entities) belonging to a specific package are stored together in the same directory. Furthermore, they are stored in a sub-directory structure specified by its package name. For example, the class Circle of package com.zzz.project1.subproject2 is stored as “$BASE_DIR\com\zzz\project1\subproject2\Circle.class”, where $BASE_DIR denotes the base directory of the package. Clearly, the “dot” in the package name corresponds to a sub-directory of the file system. The base directory ($BASE_DIR) could be located anywhere in the file system. Hence, the Java compiler and runtime must be informed about the location of the $BASE_DIR so as to locate the classes. This is accomplished by an environment variable called CLASSPATH. CLASSPATH is similar to another environment variable PATH, which is used by the command shell to search for the executable programs.

Setting CLASSPATH: CLASSPATH can be set by any of the following ways:

  • CLASSPATH can be set permanently in the environment: In Windows, choose control panel ? System ? Advanced ? Environment Variables ? choose “System Variables” (for all the users) or “User Variables” (only the currently login user) ? choose “Edit” (if CLASSPATH already exists) or “New” ? Enter “CLASSPATH” as the variable name ? Enter the required directories and JAR files (separated by semicolons) as the value (e.g., “.;c:\javaproject\classes;d:\tomcat\lib\servlet-api.jar”). Take note that you need to include the current working directory (denoted by ‘.’) in the CLASSPATH. To check the current setting of the CLASSPATH, issue the following command:
  • CLASSPATH can be set temporarily for that particular CMD shell session by issuing the following command:
    > SET CLASSPATH=.;c:\javaproject\classes;d:\tomcat\lib\servlet-api.jar
  • Instead of using the CLASSPATH environment variable, you can also use the command-line option -classpath or -cp of the javac and java commands, for example,
    > java –classpath c:\javaproject\classes

Illustration of user-defined packages: Creating our first package: File name –

package package_name;

public class ClassOne {
    public void methodClassOne()
        System.out.println("Hello there its ClassOne");

Creating our second package: File name –

package package_one;

public class ClassTwo {
    public void methodClassTwo()
        System.out.println("Hello there i am ClassTwo");

Making use of both the created packages: File name –

import package_name.ClassOne;
import package_one.ClassTwo;

public class Testing {
    public static void main(String[] args)
        ClassTwo a = new ClassTwo();
        ClassOne b = new ClassOne();


Hello there i am ClassTwo
Hello there its ClassOne

Now having a look at the directory structure of both the packages and the testing class file:

Directory structure

Important points:

  1. Every class is part of some package.
  2. If no package is specified, the classes in the file goes into a special unnamed package (the same unnamed package for all files).
  3. All classes/interfaces in a file are part of the same package. Multiple files can specify the same package name.
  4. If package name is specified, the file must be in a subdirectory called name (i.e., the directory name must match the package name).
  5. We can access public classes in another (named) package using: package-name.class-name

Related Article: Quiz on Packages in Java


Previous Article
Next Article

Similar Reads

Java - Divide the Classes into Packages with Examples
Let us first know what is a class and package in Java. Class in java is a model for creating objects. It means that the properties and actions of the objects are written in class. Properties are represented by variables and actions of the objects are represented by methods. So, a class contains variables and methods. The same variables are also ava
6 min read
How to Create Different Packages For Different Classes in Java?
Let us first know what is a class and package in Java. Class in java is a model for creating objects. It means that the properties and actions of the objects are written in class. Properties are represented by variables and actions of the objects are represented by methods. So, a class contains variables and methods. The same variables are also ava
6 min read
User-Defined Packages in Java
Packages in Java are a mechanism to encapsulate a group of classes, interfaces, and sub-packages. In Java, it is used for making search/locating and usage of classes, interfaces, enumerations, and annotations easier. It can be considered data encapsulation also. In other words, we can say a package is a container of a group of related classes where
3 min read
Built-in Packages in Java
Packages in java are used to avoid naming conflict and to control the access of class, interface, sub-classes, etc. A package can be defined as a group of similar types of classes, sub-classes, interfaces or enumerations, etc. while using packages it becomes easier to locate or find the related classes and packages provides a good structure or outl
8 min read
Overriding methods from different packages in Java
Prerequisite : Overriding in Java, Packages in Java Packages provide more layer of encapsulation for classes. Thus, visibility of a method in different packages is different from that in the same package. How JVM find which method to call? When we run a java program, JVM checks the runtime class of the object. JVM checks whether the object's runtim
3 min read
Servlet - Packages
Servlets are the Java programs that run on the Java-enabled web server or application server. They are used to handle the request obtained from the webserver, process the request, produce the response, then send a response back to the webserver. A package in servlets contains numerous classes and interfaces Remember: In order to create servlet in p
6 min read
Difference Between java.sql.Time, java.sql.Timestamp and java.sql.Date in Java
Across the software projects, we are using java.sql.Time, java.sql.Timestamp and java.sql.Date in many instances. Whenever the java application interacts with the database, we should use these instead of java.util.Date. The reason is JDBC i.e. java database connectivity uses these to identify SQL Date and Timestamp. Here let us see the differences
7 min read
How to Convert java.sql.Date to java.util.Date in Java?
If we have the Date object of the SQL package, then we can easily convert it into an util Date object. We need to pass the getTime() method while creating the util Date object. java.util.Date utilDate = new java.util.Date(sqlDate.getTime()); It will give us util Date object. getTime() method Syntax: public long getTime() Parameters: The function do
1 min read
Different Ways to Convert java.util.Date to java.time.LocalDate in Java
Prior to Java 8 for handling time and dates we had Date, Calendar, TimeStamp (java.util) but there were several performance issues as well as some methods and classes were deprecated, so Java 8 introduced some new concepts Date and Time APIs' (also known as Joda time APIs') present in java.time package. Java 7: Date, Calendar, TimeStamp present ins
3 min read
How to Convert java.util.Date to java.sql.Date in Java?
Date class is present in both java.util package and java.sql package. Though the name of the class is the same for both packages, their utilities are different. Date class of java.util package is required when data is required in a java application to do any computation or for other various things, while Date class of java.sql package is used whene
3 min read
Article Tags :
Practice Tags :