Packages

Introduction

• Java packages are used to organize classes and

interfaces.
• Helps avoid class name conflicts and makes
code modular.
• We will cover package creation, setting
CLASSPATH, access control, and importing
packages.
 What is a Package?

• A package is a namespace that organizes

classes and interfaces.
• Similar to folders in an operating system.
Example:
package mypackage;
public class MyClass {
public void display() {
System.out.println("Hello from MyClass");
}
}
 Creating a Package
• Define a package using the package keyword.
• Store the class inside a corresponding directory structure.
• Example:
package utilities;
public class Utility {
public static void printMessage() {
System.out.println("Utility message");
}
}

Compiling and Running a Package

• Compile: javac -d . Utility.java
• Run: java utilities.Utility
 Setting CLASSPATH
• CLASSPATH tells JVM where to look for classes.
• Can be set using the -cp option or
environment variable.
• Example:
export CLASSPATH=/path/to/classes
 Creating User-Defined Packages with Math Operations

• We can create a package for mathematical operations.

• Example:
package mathoperations;
public class MathUtils {
public static int add(int a, int b) {
return a + b;
}
public static int subtract(int a, int b) {
return a - b;
}
}
 Using the MathOperations Package

• Import the user-defined package and use it.

• Example:
import mathoperations.MathUtils;
public class Main {
public static void main(String[] args) {
System.out.println("Addition: " + MathUtils.add(5, 3));
System.out.println("Subtraction: " + MathUtils.subtract(10, 4));
}
}
 Creating a Package with Multiple Classes

• A package can have multiple classes.

• Example:
package shapes;
public class Circle {
public double area(double radius) {
return Math.PI * radius * radius;
}
}
public class Rectangle {
public int area(int length, int breadth) {
return length * breadth;
}
}
 Using the Shapes Package
import shapes.Circle;
import shapes.Rectangle;
public class Demo {
public static void main(String[] args) {
Circle c = new Circle();
Rectangle r = new Rectangle();
System.out.println("Circle Area: " + c.area(5));
System.out.println("Rectangle Area: " + r.area(4, 6));
}
}
 Access Control Modifiers

• public: Accessible from anywhere.

• protected: Accessible within package and
subclasses.
• default: Accessible only within package.
• private: Accessible only within class.
• Public Access Modifier • Private Access Modifier
Example Example
package example; package example;
public class PublicClass { public
class PrivateExample
void show()
{ System.out.println("Public { private void show() {
method"); System.out.println("Pri
} vate method");
} }
}
Protected Access Modifier Example Default Access Modifier Example
package example;
public class ProtectedExample{ package example;
protected void show() class DefaultExample {
{ System.out.println("Protect
void show()
ed method");
{ System.out.println("Default
} method");
} }
}
 Importing Packages

• Use import keyword to use classes from

another package.
• Example:
import utilities.Utility;
class Main {
public static void main(String args[]) {
Utility.printMessage();
}
}
 Importing All Classes

• Use wildcard * to import all classes in a package.

import utilities.*;

Static Import
• Import static members of a class directly.
• Example:
import static utilities.Utility.printMessage;
class Main {
public static void main(String args[]) { printMessage();
}
}
Creating and Using a Package
• This example defines a package named mypackage and a
class inside it.
Step 1: Create a package and class (Save as MyClass.java)
// Package declaration
package mypackage;

public class MyClass {

public void displayMessage() {
System.out.println("Hello from MyClass in
mypackage!");
}
}
Step 2: Use the package in another Java program (Save as
TestPackage.java)

// Importing the package

import mypackage.MyClass;

public class TestPackage {

public static void main(String[] args) {
MyClass obj = new MyClass();
obj.displayMessage(); // Calling the method
}
}
Compilation and Execution:
javac -d . MyClass.java
javac -d . TestPackage.java
java TestPackage
 2. Using Multiple Classes in a Package
Step 1: Define multiple classes inside a package (mypackage)

// File: Message.java
package mypackage;

public class Message {

public void showMessage() {
System.out.println("This is a message from the mypackage.");
}
}

// File: Greetings.java
package mypackage;

public class Greetings {

public void greet() {
System.out.println("Hello! Greetings from mypackage.");
}
}
Step 2: Access both classes in another program
// File: PackageDemo.java
import mypackage.Message;
import mypackage.Greetings;

public class PackageDemo {

public static void main(String[] args) {
Message msg = new Message();
Greetings greet = new Greetings();

msg.showMessage();
greet.greet();
}
}

javac -d . Message.java Greetings.java

javac -d . PackageDemo.java
java PackageDemo
 3. Using Sub-Packages
Step 1: Create a subpackage (mypackage.subpackage)

// File: SubPackageClass.java
package mypackage.subpackage;

public class SubPackageClass {

public void display() {
System.out.println("Inside the subpackage:
mypackage.subpackage");
}
}
Step 2: Access the subpackage in another program

// File: SubPackageDemo.java
import mypackage.subpackage.SubPackageClass;

public class SubPackageDemo {

public static void main(String[] args) {
SubPackageClass obj = new SubPackageClass();
obj.display();
}
}
Compilation and Execution:
javac -d . SubPackageClass.java
javac -d . SubPackageDemo.java
java SubPackageDemo
4. Using static import for accessing static members
// File: MathUtil.java
package mypackage;

public class MathUtil {

public static int square(int x) {
return x * x;
}
}

// File: StaticImportDemo.java
import static mypackage.MathUtil.square;

public class StaticImportDemo {

public static void main(String[] args) {
int num = 5;
System.out.println("Square of " + num + " is: " + square(num));
}
}
Compilation and Execution:
javac -d . MathUtil.java
javac -d . StaticImportDemo.java
java StaticImportDemo
 Conclusion

• Java packages help in organizing code.

• CLASSPATH ensures JVM finds the right
classes.
• Access modifiers control class visibility.
• Importing packages allows code reuse.