Protected fields not visible to subclasses

Protected Fields and Subclasses in Object-Oriented Programming

In object-oriented programming (OOP), one of the key concepts is encapsulation, which involves hiding data and methods within a class, exposing only the necessary information to the outside world. Protected fields play a crucial role in this process, offering a middle ground between private and public access levels. This article delves into the concept of protected fields and their interactions with subclasses.

Understanding Protected Fields

What are Protected Fields?

Protected fields are a type of member variable in a class that can be accessed by:

• Instances of the same class: Objects created from the class can directly access and modify protected fields.
• Subclasses: Classes that inherit from the parent class can access and modify protected fields.

Access Restrictions

Protected fields are not accessible from outside the class or its subclasses. This restriction helps maintain data integrity and ensures that only authorized entities can modify the internal state of an object.

Protected Fields and Inheritance

The Inheritance Relationship

When a class inherits from another class, it gains access to all the parent class’s public and protected members. However, private members remain inaccessible to the subclass.

Protected Fields and Subclass Access

Subclasses can access and modify protected fields of their parent class. This provides a controlled way for subclasses to interact with and extend the parent class’s data and functionality.

Example: Protected Fields in Action

class Animal {
  protected String name;
  protected int age;

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

  public String getName() {
    return name;
  }
}

class Dog extends Animal {
  public Dog(String name, int age) {
    super(name, age);
  }

  public void bark() {
    System.out.println("Woof! I'm " + name + " and I'm " + age + " years old.");
  }
}

public class Main {
  public static void main(String[] args) {
    Dog myDog = new Dog("Buddy", 3);
    myDog.bark(); // Output: Woof! I'm Buddy and I'm 3 years old.

    // Accessing protected field from subclass:
    System.out.println(myDog.name); // Output: Buddy
  }
}

In this example, the name and age fields are declared as protected in the Animal class. The Dog class inherits from Animal and can access these protected fields. The bark() method demonstrates how the subclass uses the inherited protected fields to display information about the dog.

Why Use Protected Fields?

Protected fields offer several advantages in OOP design:

• Data Hiding: Protected fields protect the internal state of a class from external access, promoting encapsulation.
• Controlled Access: Subclasses are allowed to access and modify protected fields, allowing for extensions and customization while preventing direct manipulation from unrelated classes.
• Code Reusability: Inheritance with protected fields enables subclasses to leverage the parent class’s data and functionality without unnecessary code duplication.

Comparison with Private and Public Fields

Conclusion

Protected fields provide a well-defined mechanism for managing access to class members, balancing encapsulation with the need for controlled access by subclasses. This careful balancing act ensures that object-oriented programs remain well-structured, maintainable, and adaptable to future changes.