Packages

Introduction

Package is a container/folder that groups related classes and interfaces. It helps organize code and avoid naming conflicts.

Creating a Package

Syntax:

package packageName;

// Rest of the code

Example:

// File: Student.java
package school;

public class Student {
    String name;
    int rollNo;

    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Roll No: " + rollNo);
    }
}

Package Structure

project/
├── school/
│   ├── Student.java
│   └── Teacher.java
├── library/
│   ├── Book.java
│   └── Library.java
└── Main.java

Using Classes from Packages

1. Using Fully Qualified Name:

public class Main {
    public static void main(String[] args) {
        school.Student s = new school.Student();
        s.name = "John";
        s.display();
    }
}

2. Using import Statement:

import school.Student;

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "John";
        s.display();
    }
}

3. Import All Classes:

import school.*;  // Import all classes from school package

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        Teacher t = new Teacher();
    }
}

Built-in Packages

Common Java Packages:

Examples:

import java.util.Scanner;      // Scanner class
import java.util.ArrayList;    // ArrayList class
import java.io.File;           // File class
import java.io.FileReader;     // FileReader class

Complete Example

File: mypackage/Calculator.java

package mypackage;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }
}

File: Main.java

import mypackage.Calculator;

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();

        System.out.println("Sum: " + calc.add(10, 20));
        System.out.println("Product: " + calc.multiply(5, 6));
    }
}

Subpackages

Packages can contain other packages.

company/
├── employee/
│   ├── Manager.java
│   └── Developer.java
├── department/
│   ├── HR.java
│   └── IT.java

Example:

// File: company/employee/Manager.java
package company.employee;

public class Manager {
    public void manage() {
        System.out.println("Managing...");
    }
}

// Usage:
import company.employee.Manager;

Manager m = new Manager();
m.manage();

Package Naming Convention

Rules:

• Use lowercase letters
• Reverse domain name (for companies)
• Descriptive names

Examples:

package com.company.project;      // Company package
package org.example.utils;        // Organization
package school.management;        // Simple project
package library.books;            // Project package

Access Control with Packages

package mypackage;

public class Public {       // Accessible everywhere
}

class Default {             // Only within same package
}

Compilation and Execution

Compile with Package:

javac -d . Calculator.java
# Creates: mypackage/Calculator.class

Run:

java Main

With Directory Structure:

# Create package directory
mkdir mypackage

# Move or create file in package
# mypackage/Calculator.java

# Compile
javac mypackage/Calculator.java

# Compile main
javac Main.java

# Run
java Main

Multiple Packages Example

Package 1: school

// school/Student.java
package school;

public class Student {
    public String name;
    public int rollNo;
}

Package 2: library

// library/Book.java
package library;

public class Book {
    public String title;
    public String author;
}

Using Both:

import school.Student;
import library.Book;

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "John";

        Book b = new Book();
        b.title = "Java Programming";
    }
}

Static Import

Import static members directly.

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        // Use directly without Math.
        System.out.println(PI);        // Instead of Math.PI
        System.out.println(sqrt(16));  // Instead of Math.sqrt(16)
    }
}

Benefits of Packages

1. Organization: Group related classes
2. Namespace: Avoid naming conflicts
3. Access Control: Package-level access
4. Reusability: Easy to reuse code
5. Maintainability: Better code structure

java.lang Package

Automatically imported - no need for import statement.

public class Main {
    public static void main(String[] args) {
        String s = "Hello";     // java.lang.String
        System.out.println(s);  // java.lang.System
        int x = Integer.parseInt("10");  // java.lang.Integer
    }
}

Package vs Import

// File structure:
// mypackage/MyClass.java

package mypackage;           // This class is in mypackage
import java.util.ArrayList;  // Using ArrayList from java.util

public class MyClass {
    // ...
}

Quick Reference

// Create package
package packageName;

// Import specific class
import packageName.ClassName;

// Import all classes
import packageName.*;

// Static import
import static packageName.ClassName.memberName;

// Fully qualified name (no import needed)
packageName.ClassName obj = new packageageName.ClassName();

Exam Tips

Remember:

1. package statement must be first (before imports)
2. One package per file
3. Use lowercase for package names
4. java.lang automatically imported
5. import brings classes from other packages
6. Use dot (.) for subpackages
7. public class accessible from other packages
8. default class only in same package
9. Package = folder structure
10. Helps avoid name conflicts

Common Questions:

• What is a package?
• How to create a package?
• How to use classes from other packages?
• What is import statement?
• Which package is automatically imported?
• Benefits of packages?
• Package naming convention?