Java Packages

Packages in Java are a mechanism that encapsulates a group of classes, sub-packages, and interfaces. Packages are used for:

• Prevent naming conflicts by allowing classes with the same name to exist in different packages, like college.staff.cse.Employee and college.staff.ee.Employee.
• They make it easier to organize, locate, and use classes, interfaces, and other components.
• Packages also provide controlled access for Protected members that are accessible within the same package and by subclasses.
• Also, default members (no access specifier) are accessible only within the same package.

By grouping related classes into packages, Java promotes data encapsulation, making code reusable and easier to manage. Simply import the desired class from a package to use it in your program.

Creating Custom Packages

Step 1: Create a directory in which we create our packages and Java files.

mkdir PROGRAMMING

Step 2: Now, change the directory and create another folder inside the main folder

cd PROGRAMMING

mkdir JavaProgramming

cd JavaProgramming

mkdir arrays

Step 3: Now create an empty text file and write the below Java code, and don't forget to save it with the same name as the class with .java extension (TwoPointers.java)

TwoPointers Class:

// Defining a class inside a package
// Package name is JavaProgramming.arrays
package JavaProgramming.arrays;

// Main class present inside the package 
public class TwoPointers {

    public static void main(String[] args) {
        System.out.println("Inside the package");
    }
}

Note: Do not forget to add the package name inside the program file.

Step 4: Now run the program with the define folder path

javac src\JavaProgramming\arrays\TwoPointers.java

src/JavaProgramming/arrays/TwoPointers.java

Output:

Folder Structure:

This is the visual representation of a custom package in Java in the below image. First, we create a folder named Progamming and inside it we create a package Javaprogramming and then create another subpackage, which is called arrays. Then, we create a Java class file inside it, which is shown in the image below:

Working of Java Packages

Directory Structure: Package names and directory structures are closely related. For example, if a package name is college.staff.cse, then three directories are, college, staff, and cse, where cse is inside staff, and staff is inside the college.

Naming Conventions: Package names are written in reverse order of domain names, e.g., org.geeksforgeeks.practice. In a college, the convention might be:

• college.tech.cse
• college.tech.ee
• college.art.history

Example:

import java.util.*;

Here, util is a sub-package created inside the java package.  

Accessing Classes Inside a Package

In Java, we can import classes from a package using either of the following methods:

1. Import a specific class:

import java.util.Vector;

This imports only the Vector class from the java.util package.

2. Import all classes from a package:

import java.util.*;

This imports all classes and interfaces from the java.util package but does not include sub-packages.

Example: Importing Class

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

public class Geeks {
  
    public Geeks() {
      
        // java.util.Vector is imported, We are
        // able to access it directly in our code.
        Vector v = new Vector();

        // java.util.ArrayList is not imported
        // We are referring to it using the complete
        // package name.
        java.util.ArrayList l = new java.util.ArrayList();
        l.add(3);
        l.add(5);
        l.add(7);
        
        System.out.println(l);
    }

    public static void main(String[] args) {
      
        // Creating an instance of Geeks 
        // class to invoke the constructor
        new Geeks();
    }
}

[3, 5, 7]

Note:

• Using import package.*; imports all classes in a package, but not classes from its sub-packages.
• When two packages have classes with the same name (e.g., java.util.Date and my.package.Date), use the fully qualified name to avoid conflicts:

import java.util.Date;

import my.package.Date;

Types of Java Packages

• Built-in Packages
• User-defined Packages

1. 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:

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

2. User-defined Packages

These are the packages that are defined by the user.

1. Create the Package:

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)
    {        
        System.out.println(s);        
    }
}

2. Use the Class in Program:

Now we will use the MyClass class in our program.

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

public class Geeks {
   public static void main(String args[]) {  
     
      // Initializing the String variable 
      // with a value 
      String s = "GeeksforGeeks";
      
      // Creating an instance of class MyClass in 
      // the package.
      MyClass o = new MyClass();
      
      o.getNames(s);
   }
}

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

Static Import In Java

Static Import in Java is about simplifying access to static members and separates it from the broader discussion of user-defined packages.

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.

Example:

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

class Geeks {
    public static void main(String args[]) {
      
        // We don't need to use 'System.out'
        // as imported using static.
        out.println("GeeksforGeeks");
    }
}

GeeksforGeeks

Handling Name Conflicts

When two packages contain a class with the same name (e.g., java.util.Date and java.sql.Date), specify the full package name to avoid conflicts.

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 and CLASSPATH

Package names correspond to a directory structure. For example, a class Circle in package com.zzz.project1.subproject2 is stored as:

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Here $BASE_DIR represents the base directory of the package.
• 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.
• It is 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 the steps In Windows is

Go to Control Panel -> System -> Advanced -> Environment Variables.

• Select "System Variables" to apply the CLASSPATH for all users on the system.
• Select "User Variables" to apply it only for the currently logged-in user.
• Edit or Create CLASSPATH : If CLASSPATH already exists, select it and click "Edit" or If it doesn't exist, click "New"
• Enter CLASSPATH Details: In the "Variable name" field, enter: "CLASSPATH", In the "Variable value" field, enter the directories and JAR files separated by semicolons.
• In the "Variable value" field, enter the directories and JAR files separated by semicolons. Example:

.c:\javaproject\classes;d:\tomcat\lib\servlet-api.jar

• The dot (.) represents the current working directory.
• To check the current setting of the CLASSPATH, issue the following command:

> SET CLASSPATH

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 com.abc.project1.subproject2.MyClass3

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

package package_name;

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

Creating our second package: File name – ClassTwo.java

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 – Testing.java

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();
        a.methodClassTwo();
        b.methodClassOne();
    }
}

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

Access Modifiers in the Context of Packages

• Public: Members with the public modifier are accessible from anywhere, regardless of whether the accessing class is in the same package or not.
• Protected: Members with the protected modifier are accessible within the same package, In subclasses
• Default: Members with no modifier are accessible only within the same package
• Private: Members with the private modifier are accessible only within the same class. They cannot be accessed by classes in the same package, subclasses, or different packages.

Important points:

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