Packages & Access Modifiers in Java

---

In Java, packages and access modifiers are essential concepts that help you organize and secure your code.

• Packages group related classes and interfaces together for better project structure.
• Access modifiers control who can access those classes, methods, and variables.

Together, they make your Java program modular, reusable, and secure.

---

What is a Package in Java?

A package is a namespace that organizes related classes and interfaces.

Think of it as a folder in your computer that helps keep your files (classes) organized.

com.myapp.utils

Here:

• com → main domain package
• myapp → project name
• utils → sub-package (utility classes)

Benefits of Using Packages

• Avoids name conflicts between classes.
• Makes code modular and easier to maintain.
• Enables access control using access modifiers.
• Supports reusability by importing only what’s needed.

---

Types of Packages

Java provides two types of packages:

Type	Description	Example
Built-in (Predefined)	Already available in Java API	java.util, java.io, java.lang
User-defined	Created by developers	com.myapp.utils, school.student

---

Example – Built-in Package

import java.util.Scanner; // importing predefined class

public class InputExample {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = sc.nextLine();
        System.out.println("Hello, " + name);
    }
}

Here, java.util is a built-in package, and Scanner is a class inside that package.

---

Example – User-defined Package

// File: mypack/Message.java
package mypack;

public class Message {
    public void display() {
        System.out.println("Welcome to Java Packages!");
    }
}

// File: Main.java
import mypack.Message;

public class Main {
    public static void main(String[] args) {
        Message m = new Message();
        m.display();
    }
}

Output:

Welcome to Java Packages!

---

Access Modifiers in Java

Access modifiers define how accessible a class, method, or variable is from other classes or packages.

There are four main access levels in Java:

1. private Access Modifier

• The most restrictive access level.
• Members declared private are accessible only within the same class.
• Not visible in subclasses or anywhere else.

public class PrivateExample {
    private int data = 42;

    private void display() {
        System.out.println("Private data: " + data);
    }

    public static void main(String[] args) {
        PrivateExample obj = new PrivateExample();
        obj.display(); // Accessible here
    }
}

class TestPrivate {
    public static void main(String[] args) {
        // PrivateExample obj = new PrivateExample();
        // obj.display();  Error - display() is private
    }
}

---

2. Default Access Modifier (Package-Private)

• When no modifier is specified, it becomes default.
• Accessible only within the same package.
• Not visible outside the package — even to subclasses.

package mypack;

class Example {
    void show() {
        System.out.println("Default access modifier example");
    }
}

public class TestDefault {
    public static void main(String[] args) {
        Example e = new Example();
        e.show(); // Works - same package
    }
}

package anotherpack;

import mypack.Example;

public class TestOutside {
    public static void main(String[] args) {
        // Example e = new Example();  Error - not accessible
    }
}

---

3. protected Access Modifier

• The protected modifier gives access within the same package and to subclasses (even in different packages).
• Useful for inheritance.

Example:

package mypack;

public class Parent {
    protected void display() {
        System.out.println("Protected method in Parent class");
    }
}

package anotherpack;

import mypack.Parent;

class Child extends Parent {
    void show() {
        display(); // Accessible because Child is a subclass
    }

    public static void main(String[] args) {
        Child c = new Child();
        c.show();
    }
}

Output:

Protected method in Parent class

---

4. public Access Modifier

• Most open access level.
• Members declared public can be accessed from anywhere — inside or outside the package.
• Commonly used for API methods or shared classes.

Example:

package mypack;

public class A {
    public void show() {
        System.out.println("Public method in class A");
    }
}

package anotherpack;

import mypack.A;

public class TestPublic {
    public static void main(String[] args) {
        A obj = new A();
        obj.show(); // Accessible everywhere
    }
}

Output:

Public method in class A

---

Diagram:

+-----------------+           +-----------------+
|   Package A     |           |   Package B     |
|-----------------|           |-----------------|
| Class1 (public) |           | Class3 (public) |
| Class2 (private)|           | Class4 (protected)|
+-----------------+           +-----------------+

Access Levels:
- public: Accessible from anywhere
- protected: Accessible in same package + subclasses
- default: Accessible in same package only
- private: Accessible within class only

Example – Combining Packages and Access Modifiers

// File: company/Employee.java
package company;

public class Employee {
    protected int id;
    public String name;

    public void display() {
        System.out.println("ID: " + id + ", Name: " + name);
    }
}

// File: office/Main.java
package office;
import company.Employee;

public class Main extends Employee {
    public static void main(String[] args) {
        Main emp = new Main();
        emp.id = 101; // accessible (protected)
        emp.name = "John";
        emp.display();
    }
}

Output:

ID: 101, Name: John

---

Points to Remember

• Packages organize related classes.
• Access modifiers control visibility and security.
• Import statement is used to access classes from other packages.
• Protected gives access to subclasses across packages.
• Private members cannot be accessed outside their class.

Real-world Example Addition

Scenario: Employee Management System

// File: company/Employee.java
package company;

public class Employee {
    protected int id;        // accessible in subclasses
    public String name;      // accessible anywhere

    public void display() {
        System.out.println("ID: " + id + ", Name: " + name);
    }
}

// File: office/Main.java
package office;
import company.Employee;

public class Main extends Employee {
    public static void main(String[] args) {
        Main emp = new Main();
        emp.id = 101;          // protected → accessible because Main extends Employee
        emp.name = "John";     // public → accessible anywhere
        emp.display();
    }
}

Output :

ID: 101, Name: John