Java Programming Language

Chapter 8: Packages and Access Control

Organizing and Securing Java Code

Course: 4343203 - Java Programming

What We'll Cover

Package Fundamentals
Creating and Using Packages
Import Statements
Access Modifiers
Access Control Levels
Package-Level Access
CLASSPATH and Package Structure
Java Built-in Packages

Package Structure

Package Fundamentals

Packages are namespaces that organize related classes and interfaces

What are Packages?

Package Benefits:

Organize related classes and interfaces
Provide namespace to avoid name conflicts
Control access with package-level visibility
Create logical groups of functionality
Enable modular programming

Package Declaration:


// File: com/company/utils/Calculator.java
package com.company.utils;

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

Directory Structure:


src/
  com/
    company/
      utils/
        Calculator.java
        MathUtils.java
      models/
        Student.java
        Course.java
      main/
        Application.java

Rules:

package statement must be first
Only one package per file
Directory structure matches package

Package Naming Conventions

Standard Convention

All lowercase
Reverse domain name
Dot-separated
Descriptive names

Examples

com.oracle.jdbc
org.apache.commons
edu.university.cs
gov.agency.module

Avoid

java.* (reserved)
javax.* (reserved)
Single word packages
Mixed case

Creating and Using Packages

Creating Package Example

shapes/Circle.java:


package shapes;

public class Circle {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    public double getCircumference() {
        return 2 * Math.PI * radius;
    }
    
    public void display() {
        System.out.println("Circle with radius: " + radius);
        System.out.println("Area: " + getArea());
    }
}

shapes/Rectangle.java:


package shapes;

public class Rectangle {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    public double getArea() {
        return width * height;
    }
    
    public double getPerimeter() {
        return 2 * (width + height);
    }
    
    public void display() {
        System.out.println("Rectangle: " + width + "x" + height);
        System.out.println("Area: " + getArea());
    }
}

Using Packages with Import

main/TestShapes.java:


package main;

// Import specific classes
import shapes.Circle;
import shapes.Rectangle;

// Or import all classes from package
// import shapes.*;

public class TestShapes {
    public static void main(String[] args) {
        // Using imported classes
        Circle circle = new Circle(5.0);
        circle.display();
        
        Rectangle rect = new Rectangle(4.0, 6.0);
        rect.display();
        
        // Without import (fully qualified name)
        shapes.Circle anotherCircle = 
            new shapes.Circle(3.0);
        anotherCircle.display();
    }
}

Compilation and Execution:


# Compile with package structure
javac -d . shapes/*.java main/TestShapes.java

# Directory structure after compilation:
src/
  shapes/
    Circle.class
    Rectangle.class
  main/
    TestShapes.class

# Run with package name
java main.TestShapes

Key Points:

-d . creates directory structure
Run with full package.ClassName
CLASSPATH must include root directory

Import Statements

Import statements allow you to use classes from other packages without fully qualified names

Types of Import Statements

Single Type Import:


import java.util.ArrayList;
import java.util.HashMap;
import java.io.File;

public class Example1 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        HashMap map = new HashMap<>();
        File file = new File("test.txt");
    }
}

On-Demand Import:


import java.util.*;
import java.io.*;

public class Example2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        HashMap map = new HashMap<>();
        File file = new File("test.txt");
        Scanner scanner = new Scanner(System.in);
    }
}

Static Import:


import static java.lang.Math.*;
import static java.lang.System.out;

public class Example3 {
    public static void main(String[] args) {
        // Using static imports
        double result = sqrt(16);   // Math.sqrt()
        double power = pow(2, 3);   // Math.pow()
        out.println(result);        // System.out.println()
        out.println(power);
        
        // Constants
        out.println("PI = " + PI);  // Math.PI
        out.println("E = " + E);    // Math.E
    }
}

Avoiding Name Conflicts:


import java.util.Date;
import java.sql.Date; // Compilation error!

// Solution: Use fully qualified names
public class DateExample {
    public static void main(String[] args) {
        java.util.Date utilDate = new java.util.Date();
        java.sql.Date sqlDate = new java.sql.Date(
            System.currentTimeMillis());
    }
}

Access Modifiers

Access modifiers control the visibility and accessibility of classes, methods, and variables

Access Modifiers Scope & Visibility

Java Access Modifiers Scope and Visibility

Access Control Levels

Modifier	Same Class	Same Package	Subclass	Different Package
private	✓	✗	✗	✗
default	✓	✓	✗	✗
protected	✓	✓	✓	✗
public	✓	✓	✓	✓

Access Modifier Examples

package1/ClassA.java:


package package1;

public class ClassA {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;      // package-private
    private int privateVar = 4;
    
    public void publicMethod() {
        System.out.println("Public method");
    }
    
    protected void protectedMethod() {
        System.out.println("Protected method");
    }
    
    void defaultMethod() {
        System.out.println("Default method");
    }
    
    private void privateMethod() {
        System.out.println("Private method");
    }
    
    public void testAccess() {
        // All accessible within same class
        System.out.println(publicVar);
        System.out.println(protectedVar);
        System.out.println(defaultVar);
        System.out.println(privateVar);
        
        publicMethod();
        protectedMethod();
        defaultMethod();
        privateMethod();
    }
}

package1/ClassB.java:


package package1;

public class ClassB {
    public void testAccess() {
        ClassA obj = new ClassA();
        
        // Accessible in same package
        System.out.println(obj.publicVar);     // ✓
        System.out.println(obj.protectedVar);  // ✓
        System.out.println(obj.defaultVar);    // ✓
        // System.out.println(obj.privateVar); // ✗
        
        obj.publicMethod();     // ✓
        obj.protectedMethod();  // ✓
        obj.defaultMethod();    // ✓
        // obj.privateMethod(); // ✗
    }
}

package2/ClassC.java:


package package2;
import package1.ClassA;

public class ClassC extends ClassA {
    public void testAccess() {
        // Accessible to subclass
        System.out.println(publicVar);     // ✓
        System.out.println(protectedVar);  // ✓
        // System.out.println(defaultVar);    // ✗
        // System.out.println(privateVar);    // ✗
        
        publicMethod();     // ✓
        protectedMethod();  // ✓
        // defaultMethod();    // ✗
        // privateMethod();    // ✗
    }
}

Package-Level Access

Default access (no modifier) provides package-level visibility

Package-Private Members

utilities/Helper.java:


package utilities;

// Package-private class
class Helper {
    // Package-private field
    String name;
    
    // Package-private constructor
    Helper(String name) {
        this.name = name;
    }
    
    // Package-private method
    void performTask() {
        System.out.println(name + " performing task");
    }
}

public class UtilityManager {
    public void useHelper() {
        // Can access package-private class
        Helper helper = new Helper("Manager Helper");
        helper.performTask();
    }
}

utilities/Calculator.java:


package utilities;

public class Calculator {
    // Package-private utility method
    static double internalCalculation(double x) {
        return x * 2 + 1;
    }
    
    public double calculate(double input) {
        // Can access package-private method
        return internalCalculation(input);
    }
    
    public void demonstrateAccess() {
        // Can access package-private class
        Helper helper = new Helper("Calculator Helper");
        helper.name = "Modified Name";
        helper.performTask();
    }
}

main/Application.java:


package main;
import utilities.*;

public class Application {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        // Can access public methods
        double result = calc.calculate(5.0);
        
        // Cannot access package-private
        // Helper helper = new Helper("Test"); // ✗
        // calc.internalCalculation(10);       // ✗
    }
}

CLASSPATH and Package Structure

CLASSPATH tells Java where to find class files and packages

Understanding CLASSPATH

Setting CLASSPATH:


# Windows
set CLASSPATH=.;C:\myproject\classes;C:\lib\mylib.jar

# Unix/Linux/Mac
export CLASSPATH=.:./classes:/usr/local/lib/mylib.jar

# Compilation with classpath
javac -cp ./classes:./lib/* com/company/Main.java

# Execution with classpath
java -cp ./classes:./lib/* com.company.Main

Directory Structure Example:


project/
  src/
    com/
      company/
        Main.java
        utils/
          Helper.java
  classes/    (compiled .class files)
  lib/        (external JAR files)
    commons.jar
    database.jar

Build and Run Process:


# 1. Create directory structure
mkdir -p classes

# 2. Compile with package structure
javac -d classes -cp lib/* src/com/company/*.java src/com/company/utils/*.java

# 3. Results in classes directory:
classes/
  com/
    company/
      Main.class
      utils/
        Helper.class

# 4. Run with correct classpath
java -cp classes:lib/* com.company.Main

CLASSPATH Tips:

Always include current directory (.)
Use ; on Windows, : on Unix
JAR files must be explicitly listed
Use -cp or -classpath option

Java Built-in Packages

Java Standard Library provides many useful packages

Common Java Packages

java.lang

Object, String, System
Integer, Double, Boolean
Math, Thread
Exception classes

Automatically imported

java.util

ArrayList, HashMap
Scanner, Random
Date, Calendar
Collections framework

java.io

File, FileReader
InputStream, OutputStream
BufferedReader, PrintWriter
Serialization classes

java.net

URL, URLConnection
Socket, ServerSocket
InetAddress
HTTP classes

java.awt / javax.swing

GUI components
Event handling
Graphics and painting
Layout managers

java.sql

Database connectivity
Connection, Statement
ResultSet, PreparedStatement
JDBC drivers

Using Built-in Packages


import java.util.*;
import java.io.*;
import java.net.*;

public class BuiltinPackageDemo {
    public static void main(String[] args) throws Exception {
        // java.util package
        ArrayList list = new ArrayList<>();
        list.add("Java");
        list.add("Programming");
        
        HashMap scores = new HashMap<>();
        scores.put("Alice", 95);
        scores.put("Bob", 87);
        
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();
        
        // java.io package
        File file = new File("example.txt");
        FileWriter writer = new FileWriter(file);
        writer.write("Hello, World!");
        writer.close();
        
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String content = reader.readLine();
        reader.close();
        
        // java.net package
        URL url = new URL("https://www.oracle.com");
        URLConnection connection = url.openConnection();
        
        // java.lang package (automatically imported)
        String text = "Java Programming";
        int length = text.length();
        String upper = text.toUpperCase();
        
        Math.sqrt(16);
        System.out.println("Content: " + content);
        System.out.println("Random number: " + random.nextInt(100));
    }
}

Chapter Summary

Package Concepts:

Organize related classes and interfaces
Provide namespace and avoid conflicts
Follow naming conventions
Match directory structure
Use import statements effectively

Access Control:

private: class-level access
default: package-level access
protected: inheritance access
public: universal access
CLASSPATH configuration

Next: Exception Handling

Thank You!

Questions?

Ready to explore Exception Handling!