Day-64 Java Access Modifiers

What are Access Modifiers?

Access modifiers decide who can access a class, method, or variable.

Java has four main access modifiers:

1.private – accessible only within the same class.

• Example: A private variable cannot be accessed outside its class directly.
• Used for data hiding.

2.default (package-private) – no keyword is used.

• Accessible within the same package.
• Cannot be accessed from other packages, even by subclasses.

3.protected – accessible within same package and subclasses in different packages.

• Mostly used in inheritance to share with child classes.

4.public – accessible from anywhere.

Quick Rules Table

Why no protected/private for top-level classes?

• Private/protected cannot be used for top-level classes (outer classes). They are only allowed for inner classes or members within a class.
• Top-level classes can only be public or default (package-private).

Example

package electronics;

public class Mobile // same class - private, public, protected, default
{
    public Mobile()
    {  
        System.out.println("Mobile constructor"); // default constructor is always in default access modifier
    }

    public static void main(String[] args)
    {
        Mobile mob = new Mobile();
        mob.call();
        mob.satellitecall();
    }

    protected void call()
    {
        System.out.println("calling");
    }

    protected void satellitecall()
    {
        System.out.println("satellitecall");
    }
}

package electronics;

public class Samsung extends Mobile
{
    public static void main(String[] args) // same package subclass - public, default, protected
    {
        Samsung s21 = new Samsung();
        s21.call();
        s21.satellitecall();
    }
}

package grocery;

import electronics.Mobile;

public class Rice extends Mobile // different package subclass - protected, public
{
    public static void main(String[] args)
    {
        Rice mob = new Rice();
        mob.call();
        mob.satellitecall();
    }
}