Design pattern: Difference between revisions
Created page with "A '''design pattern''' is a reusable solution to a problem found in software design. Patterns are designed to leverage an existing concept instead re-inventing it, allowing developers to be more productive and increase the quality of work. A design pattern isn't a software artifact, but instead is implemented by the developer following the description of the pattern as outlined. A pattern can be made more easily reusable through the process of creating Abstraction..." |
|||
| Line 11: | Line 11: | ||
* [[Abstract factory pattern|Abstract factory]] | * [[Abstract factory pattern|Abstract factory]] | ||
* [[Builder pattern|Builder]] | * [[Builder pattern|Builder]] | ||
* [[Dependency injection pattern|Dependency injection]] | |||
* [[Factory method pattern|Factory method]] | * [[Factory method pattern|Factory method]] | ||
* [[Lazy initialization pattern|Lazy initialization]] | |||
* [[Multiton pattern|Multiton]] | |||
* [[Object pool pattern|Object pool]] | |||
* [[Prototype pattern|Prototype]] | * [[Prototype pattern|Prototype]] | ||
* [[Singleton pattern|Singleton]] | * [[Singleton pattern|Singleton]] | ||
| Line 21: | Line 25: | ||
* [[Composite pattern|Composite]] | * [[Composite pattern|Composite]] | ||
* [[Decorator pattern|Decorator]] | * [[Decorator pattern|Decorator]] | ||
* [[Delegation pattern|Delegation]] | |||
* [[Extension object pattern|Extension object]] | |||
* [[Facade pattern|Facade]] | * [[Facade pattern|Facade]] | ||
* [[Flyweight pattern|Flyweight]] | * [[Flyweight pattern|Flyweight]] | ||
* [[Front controller pattern|Front controller]] | |||
* [[Marker pattern|Marker]] | |||
* [[Module pattern|Module]] | |||
* [[Proxy pattern|Proxy]] | * [[Proxy pattern|Proxy]] | ||
* [[Twin pattern|Twin]] | |||
=== Behavioural === | === Behavioural === | ||
* [[Blackboard pattern|Blackboard]] | |||
* [[Chain of responsibility pattern|Chain of responsibility]] | * [[Chain of responsibility pattern|Chain of responsibility]] | ||
* [[Command pattern|Command]] | * [[Command pattern|Command]] | ||
* [[Fluent interface pattern|Fluent interface]] | |||
* [[Interpreter pattern|Interpreter]] | * [[Interpreter pattern|Interpreter]] | ||
* [[Iterator pattern|Iterator]] | |||
* [[Mediator pattern|Mediator]] | * [[Mediator pattern|Mediator]] | ||
* [[Memento pattern|Memento]] | * [[Memento pattern|Memento]] | ||
* [[Null object pattern|Null object]] | |||
* [[Observer pattern|Observer]] | * [[Observer pattern|Observer]] | ||
* [[Publish/Subscribe pattern|Publish/Subscribe]] | |||
* [[Servant pattern|Servant]] | |||
* [[Specification pattern|Specification]] | |||
* [[State pattern|State]] | * [[State pattern|State]] | ||
* [[Strategy pattern|Strategy]] | * [[Strategy pattern|Strategy]] | ||
* [[Template method pattern|Template method]] | * [[Template method pattern|Template method]] | ||
* [[Visitor pattern|Visitor]] | * [[Visitor pattern|Visitor]] | ||
=== Concurrency === | |||
* [[Active object pattern|Active object]] | |||
* [[Balking pattern|Balking]] | |||
* [[Binding properties pattern|Binding properties]] | |||
* [[Compute kernel pattern|Compute kernel]] | |||
* [[Double-checked locking pattern|Double-checked locking]] | |||
* [[Event-based asynchronous pattern|Event-based asynchronous]] | |||
* [[Guarded suspension pattern|Guarded suspension]] | |||
* [[Join pattern|Join]] | |||
* [[Lock pattern|Lock]] | |||
* [[Messaging design pattern]] | |||
* [[Monitor object pattern|Monitor object]] | |||
* [[Reactor pattern|Reactor]] | |||
* [[Read-write lock pattern|Read-write lock]] | |||
* [[Scheduler pattern|Scheduler]] | |||
* [[Service handler pattern|Service handler]] | |||
* [[Thread pool pattern|Thread pool]] | |||
* [[Thread-specific storage pattern|Thread-specific storage]] | |||
* | |||
== See also == | == See also == | ||
Latest revision as of 15:47, 31 October 2024
A design pattern is a reusable solution to a problem found in software design. Patterns are designed to leverage an existing concept instead re-inventing it, allowing developers to be more productive and increase the quality of work.
A design pattern isn't a software artifact, but instead is implemented by the developer following the description of the pattern as outlined. A pattern can be made more easily reusable through the process of creating abstractions of the pattern through which inheritance or polymorphism implements the code where the pattern is put into practice.
Types
Creational
- Abstract factory
- Builder
- Dependency injection
- Factory method
- Lazy initialization
- Multiton
- Object pool
- Prototype
- Singleton
Structural
- Adapter
- Bridge
- Composite
- Decorator
- Delegation
- Extension object
- Facade
- Flyweight
- Front controller
- Marker
- Module
- Proxy
- Twin
Behavioural
- Blackboard
- Chain of responsibility
- Command
- Fluent interface
- Interpreter
- Iterator
- Mediator
- Memento
- Null object
- Observer
- Publish/Subscribe
- Servant
- Specification
- State
- Strategy
- Template method
- Visitor
Concurrency
- Active object
- Balking
- Binding properties
- Compute kernel
- Double-checked locking
- Event-based asynchronous
- Guarded suspension
- Join
- Lock
- Messaging design pattern
- Monitor object
- Reactor
- Read-write lock
- Scheduler
- Service handler
- Thread pool
- Thread-specific storage