Java protected Keyword

The protected keyword in Java is an access modifier used for fields, methods, and constructors. Members declared as protected are accessible within their own package and by subclasses, even if they are in different packages. This provides a balance between private and public access, allowing for controlled access while still supporting inheritance.

Table of Contents

1. Introduction
2. protected Keyword Syntax
3. Understanding protected
4. Examples
   • Protected Fields
   • Protected Methods
   • Protected Constructors
5. Real-World Use Case
6. Conclusion

Introduction

The protected keyword is used to define members that can be accessed by classes in the same package and by subclasses in different packages. This is useful for inheritance, where you want to allow subclasses to access certain members of the superclass while keeping them hidden from other classes.

protected Keyword Syntax

Protected Field:

protected dataType fieldName;

Protected Method:

protected returnType methodName(parameters) {
    // method body
}

Protected Constructor:

protected ClassName(parameters) {
    // constructor body
}

Understanding protected

Key Points:

• Access Level: Protected members are accessible within the same package and by subclasses in different packages.
• Inheritance: Allows subclasses to access and modify protected members, promoting code reuse and modularity.
• Encapsulation: Provides more control over member visibility compared to public, but more accessibility than private.

Examples

Protected Fields

Protected fields can be accessed within the same package and by subclasses.

Example

package com.example.base;

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }
}

package com.example.derived;

import com.example.base.Animal;

public class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    public void display() {
        System.out.println("Dog's name: " + name); // Accessing protected field
    }

    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.display();
    }
}

Output:

Compilation failed.

Protected Methods

Protected methods can be overridden and accessed by subclasses.

Example

package com.example.base;

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

package com.example.derived;

import com.example.base.Animal;

public class Dog extends Animal {

    @Override
    protected void makeSound() {
        super.makeSound();
        System.out.println("Dog barks");
    }

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

Output:

Compilation failed.

Protected Constructors

Protected constructors can be used to control the instantiation of subclasses.

Example

package com.example.base;

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

package com.example.derived;

import com.example.base.Animal;

public class Dog extends Animal {

    public Dog() {
        super();
        System.out.println("Dog constructor");
    }

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

Output:

Compilation failed.

Real-World Use Case

Hierarchical Access Control

In real-world applications, the protected keyword can be used to create a class hierarchy where base class members are accessible to derived classes, but not to other classes in different packages. This is useful for creating frameworks or libraries where you want to expose certain functionalities to subclasses while keeping them hidden from other users.

Example

package com.example.framework;

public class BaseComponent {
    protected void initialize() {
        System.out.println("BaseComponent initialization");
    }

    protected void execute() {
        System.out.println("BaseComponent execution");
    }
}

package com.example.application;

import com.example.framework.BaseComponent;

public class CustomComponent extends BaseComponent {

    @Override
    protected void initialize() {
        super.initialize();
        System.out.println("CustomComponent initialization");
    }

    @Override
    protected void execute() {
        super.execute();
        System.out.println("CustomComponent execution");
    }

    public static void main(String[] args) {
        CustomComponent component = new CustomComponent();
        component.initialize();
        component.execute();
    }
}

Output:

Compilation failed.

Conclusion

The protected keyword in Java is a versatile access modifier that allows you to balance encapsulation and inheritance. By using protected, you can control access to class members, allowing them to be visible within the same package and to subclasses, even in different packages. This is useful for creating robust and maintainable code, especially in complex hierarchies and frameworks. Understanding and using protected effectively can enhance the flexibility and modularity of your Java programs.