Object-oriented design anti-patterns
From CSSEMediaWiki
(Difference between revisions)
m (→See also) |
|||
| Line 19: | Line 19: | ||
==See also== | ==See also== | ||
| − | *[[Design patterns]] | + | * [[Antipatterns]] |
| + | * [[Design patterns]] | ||
{{Design Anti-patterns}} | {{Design Anti-patterns}} | ||
[[Category: Anti-Patterns]] | [[Category: Anti-Patterns]] | ||
Revision as of 00:22, 14 September 2009
Object-oriented design anti-patterns describe bad design solutions to common problems. As such, they are essentially the opposite of conventional design patterns.
The following are common object-oriented design anti-patterns:
- Anemic Domain Model - This anti-pattern occurs when data and behavior is separated in the domain model.
- BaseBean - This anti-pattern occurs when inheritance for implementation is used; that is a class inherits from another class not because it makes sense semantically but because it wants to use methods defined in the superclass.
- Call super - This anti-pattern occurs when a superclass requires derived classes to call an overridden method.
- Circle-ellipse problem - This anti-pattern occurs when inheritance is not used correctly and the Liskov substitution principle is violated.
- Circular dependency - This anti-pattern occurs when there are two or more modules that depend directly or indirectly on each other.
- Constant interface - This anti-pattern occurs when an interface is used to declare constants but does not contain any methods.
- God object - This anti-pattern occurs when an object / class does or knows too much.
- Object cesspool - This anti-pattern occurs when an object pool is used incorrectly in that the state of objects is not reset when they are returned to the pool.
- Object orgy - This anti-pattern occurs when objects access each other internals directly rather than going through methods.
- Poltergeists - This anti-pattern occurs when temporary objects are used to initialize or call methods on more permanent objects.
- Sequential coupling - This anti-pattern occurs when a class requires clients to call methods in a particular order.
- Yo-yo problem - This problem occurs with deep inheritance hierarchies, where a programmer has to keep looking up and down the hierarchy to understand the flow of control of the program.
Many of these anti-patterns are closely related to common design maxims.
See also
| Design anti-patterns | |
|---|---|
|
Anemic Domain Model | BaseBean | Call super | Circle-ellipse problem | Circular dependency | |
