Java protected Keyword
Usage and Examples

protected Keyword in Java

In Java, the protected keyword is one of the four access modifiers used to define the visibility and accessibility of class members (fields, constructors, and methods).

When a member is declared as protected, it means:

• It is accessible within the same package (like default access).
• It is also accessible in subclasses, even if they are in different packages.

This makes protected very useful in inheritance scenarios where you want child classes to access members of the parent class without making them public.

Syntax of protected

protected datatype variableName;
protected returnType methodName() {
    // method body
}

Example 1: protected Access in Same Package

// File: Animal.java
package animals;

public class Animal {
    protected void sound() {
        System.out.println("Animals make sounds");
    }
}

// File: Dog.java
package animals;

public class Dog extends Animal {
    void bark() {
        sound();  // Accessing protected method
    }
}

// File: Main.java
package animals;

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.bark();
    }
}

Animals make sounds

Explanation:

Here, both Dog and Main are in the same package as Animal. So the protected method sound() is accessible directly in the subclass Dog.

Example 2: protected Access in Different Package via Subclass

// File: Animal.java
package animals;

public class Animal {
    protected void sound() {
        System.out.println("Animal makes sound");
    }
}

// File: Cat.java
package pets;
import animals.Animal;

public class Cat extends Animal {
    public void meow() {
        sound();  // Allowed because Cat is a subclass
    }
}

// File: Test.java
package pets;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.meow();
    }
}

Animal makes sound

Explanation:

Even though Cat is in a different package from Animal, the protected method sound() is still accessible in Cat because it extends Animal.

Important: A protected member cannot be accessed via object reference outside the package if you're not in a subclass.

Example 3: Accessing protected Member Outside Package Without Inheritance (Invalid)

// File: Animal.java
package animals;

public class Animal {
    protected void sound() {
        System.out.println("Animal sound");
    }
}

// File: Main.java
package random;

import animals.Animal;

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.sound();  // Compile-time error
    }
}

Error: sound() has protected access in Animal

Key Takeaways

• protected = package-level access + access to subclasses outside the package.
• Used mostly in inheritance to allow subclasses to access parent members safely.
• Can’t be accessed from a non-subclass in another package using object reference.

When Should You Use protected?

Use protected when:

• You want child classes to reuse or override methods of the parent class.
• You want to expose certain members but still maintain a level of encapsulation.