How to Properly Override Fields in Java Abstract Classes

What are the best practices for overriding fields in Java abstract classes?

abstract class Shape {
    String color;
    abstract void draw();
}

class Circle extends Shape {
    String color = "Red"; // This overrides the field
    void draw() {
        System.out.println("Drawing a " + color + " circle.");
    }
}

Overriding fields in Java abstract classes can be confusing due to Java's handling of fields, which differs from method overriding. Java does not technically allow overriding fields, but it allows shadowing, where a subclass defines a new field with the same name as a field in the parent class.

abstract class Animal {
    String sound = "Generic sound";

    void makeSound() {
        System.out.println(sound);
    }
}

class Dog extends Animal {
    String sound = "Bark"; // Hides the sound field

    // Override the method instead
    @Override
    void makeSound() {
        System.out.println(sound);
    }
}

Causes

• Java fields are not polymorphic like methods, meaning their values are determined at compile time rather than runtime.
• When a subclass declares a field with the same name as a parent class field, it hides the parent class field rather than overriding it.

Solutions

• To effectively manage field values from parent classes, consider using methods instead of fields, allowing polymorphic behavior.
• Use methods to access fields. In the parent class, declare getter methods to retrieve field values and override them in the subclass.

Mistake: Trying to override a field by declaring it with the same name in the subclass.

Solution: Understand that this hides the field and does not provide polymorphic behavior; instead, prefer overriding methods.

Mistake: Using direct field accesses instead of methods in subclasses.

Solution: Use getter methods to access fields, allowing subclasses to provide their own implementations.