How to Implement the Factory Design Pattern Without Using 'instanceof' in Java?

How can I avoid using the 'instanceof' keyword when implementing the Factory Design Pattern in Java?

The Factory Design Pattern is designed to encapsulate the creation logic and promote loose coupling in your code. One of the common code smells associated with Factory patterns is the use of `instanceof` to determine object types. This answer outlines strategies to avoid `instanceof` checks and promote cleaner, more maintainable code.

// Example of implementing polymorphism
public abstract class Vehicle {
    double maxSpeed;
    public Vehicle(double maxSpeed) { this.maxSpeed = maxSpeed; }
    public abstract void process();
}

class Car extends Vehicle {
    ...
    @Override
    public void process() {
        // Car specific processing
    }
}

class Boat extends Vehicle {
    ...
    @Override
    public void process() {
        // Boat specific processing
    }
}

class Plane extends Vehicle {
    ...
    @Override
    public void process() {
        // Plane specific processing
    }
}

// Usage:
for (Vehicle v : allVehicles) {
    v.process(); // No instanceof required
}

Causes

• Using `instanceof` can introduce tight coupling between classes, making the code harder to maintain and test.
• It often indicates a violation of the Open/Closed Principle, as new vehicle types require modifying existing code.

Solutions

• **Use a Visitor Pattern**: Implement the Visitor pattern which allows you to add new operations on objects without changing their structure. Each vehicle can accept a visitor that handles its type appropriately without the need for `instanceof`.
• **Implement an Interface for Vehicle**: Introduce a method in the Vehicle class or an interface that allows each subclass to handle its specific logic. For example, you could define a method like `process()` in the Vehicle class that each specific vehicle type implements accordingly.
• **Utilize Polymorphism**: Encapsulate logic that changes based on the vehicle type within the vehicle classes themselves, allowing their specific methods to take on diverse behavior without needing to check their type externally.

Mistake: Using `instanceof` checks multiple times throughout the code.

Solution: Refactor the code to implement polymorphism or use the Visitor pattern to handle variations in behavior.

Mistake: Ignoring the Open/Closed Principle by modifying classes each time a new vehicle type is added.

Solution: Use interfaces or abstract classes to extend functionality without altering existing code.