Do I really have a car in my garage?

java

polymorphism

design-patterns

collections

byAnton Shumikhin·Feb 6, 2025

boolean hasCar = garage != null && garage.getCar() != null;
System.out.println("Car in garage? " + hasCar);

The above code will instantly help you to verify if a car exists in your garage or not. It ensures that neither garage nor garage.getCar() are null, thus allowing you to avoid those pesky NullPointerExceptions.

Understanding Polymorphism

Polymorphism in Java enables us to handle instances of subclasses via references to the superclass. This means you can use a Vehicle reference to handle a Car object and Java ensures the right methods are executed.

Say `NO` to Downcasting

Remember that downcasting from a superclass to a subclass should be avoided as much as possible. It's a sign that the design can be improved. Resorting to instanceof or explicit casting indicates your design might have missed the full potential of polymorphism.

Class Designing - Doing it the Right Way

When checking for a specific type in your collection, resist the temptation of type checking. If you see yourself using instanceof, it might be a good time to rethink your design.

Bundle Vehicle Type-Specific Handling

Group the common operations in the superclass or interfaces and defer type-specific behavior to subclasses. This often leads to a cleaner design with less type checking and casting.

Put Abstract Classes to Good Use

Use abstract classes to share common methods or features. Let subclasses extend and add to this behavior, defining a blueprint for vehicles that can have unique features.

Prioritize Interfaces over Implementation

Adopting interfaces can be incredibly helpful as they define a contract of behavior. This significantly simplifies managing and identifying objects of different subclasses without necessarily knowing about their specific implementations.

Static and Dynamic Typing

The static nature of Java ensures type safety but can require casting when working with superclass collections. Dynamic languages offer alternatives, such as method invocations at runtime and less stringent casting rules.

Harness the Power of Collections

Java arrays are straightforward but limited in many ways. Using collections like List<Car> instead of List<Vehicle> can keep things strongly typed and reduce the need for casting.

Specialized Collections for Vehicles

Use distinct collections or data structures for every subclass, avoiding the need for casting and simplifying direct interaction.

Leverage java.util Collections

Java's Collections Framework offers a variety of data structures that can help manage objects more effectively. Pick the right tool for your requirement - Queue, Set, Map, or something else.

Maximize Flexibility

Think ahead and design systems that can handle changes. Utilize design patterns, strong encapsulation, and logical abstractions to keep your code clean, maintainable, and flexible.