Switch statements are bad? [closed]

by

A switch is like any other control structure. There are places where it’s the best/cleanest solution, and many more places where it’s completely inappropriate. It’s just abused way more than other control structures.

In OO design, it’s generally considered preferable in a situation like yours to use different message types/classes that inherit from a common message class, then use overloaded methods to “automatically” differentiate between the different types.

In a case like yours, you could use an enumeration that maps to your action codes, then attach an attribute to each enumerated value that will let you use generics or type-building to build different Action sub-class objects so that the overloading method will work.

But that’s a real pain.

Evaluate whether there’s a design option such as the enumeration that is feasible in your solution. If not, just use the switch.

More Related Contents:

  1. Examples of GoF Design Patterns in Java’s core libraries
  2. What is Inversion of Control?
  3. What does “program to interfaces, not implementations” mean?
  4. Does functional programming replace GoF design patterns?
  5. Where do I use delegates? [closed]
  6. Interface Segregation Principle- Program to an interface
  7. Mediator Vs Observer Object-Oriented Design Patterns
  8. What is composition as it relates to object oriented design?
  9. Can’t seem to understand SOLID principles and design patterns [closed]
  10. Differences between Proxy and Decorator Pattern
  11. Does the Single Responsibility Principle work in OOP?
  12. adapter-Any real example of Adapter Pattern [closed]
  13. Learning/Implementing Design Patterns (For Newbies) [closed]
  14. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  15. What is an example of the Liskov Substitution Principle?
  16. Inheritance vs. Aggregation [closed]
  17. Getter and Setter? [closed]
  18. HAS-A, IS-A terminology in object oriented language
  19. What is the rationale behind having companion objects in Scala?
  20. What is the dependency inversion principle and why is it important?
  21. Replacing if else statement with pattern
  22. Do write-only properties have practical applications?
  23. DDD – the rule that Entities can’t access Repositories directly
  24. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  25. If-less programming (basically without conditionals) [closed]
  26. When to implement an interface and when to extend a superclass?
  27. Mixin vs inheritance
  28. What does ‘low in coupling and high in cohesion’ mean
  29. What is the difference between a fluent interface and the Builder pattern?
  30. Is it possible to extend a default method implementation of a trait in a struct?

Leave a Comment