Design Patterns

Learn how to implement design patterns to make your software more efficient and powerful.
4.5 (4 ratings)
Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
14 students enrolled
Take This Course
  • Lectures 23
  • Length 3 hours
  • Skill Level Expert Level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works


Find online courses made by experts from around the world.


Take your courses with you and learn anywhere, anytime.


Learn and practice real-world skills and achieve your goals.

About This Course

Published 10/2014 English

Course Description

Design patterns are powerful, predefined solutions to common software design problems. Patterns provide a powerful form of reuse because they are transportable across different languages and software architectures. This seminar introduces and explains the highest-leverage design patterns in a clear way that's easy to understand. You will learn how to use specific design patterns to improve your designs, and you will practice applying design patterns to sample design problems. You will also see how design patterns can improve your design process overall.

Course Details

Fundamental Design Principles

  • Manage coupling and cohesion
  • Prefer association to inheritance
  • Encapsulate what varies
  • Information hiding
  • Separate creation and usage
  • Identify abstractions
  • Delay binding times
  • Design to interfaces
  • Design to contracts
  • Principle of least knowledge
  • Design for evolution
  • Design for testability

The Patterns ...

Abstract Factory

  • Specify object creation with an interface
  • Create families of factory methods
  • Allocate responsibility for instance creation to a service
  • Keep the client ignorant of instantiation details while maintaining conformance to a contract


  • Convert between interfaces
  • Reuse services
  • Class Adapter uses inheritance
  • Object Adapter uses association
  • Reduce the coupling between a client and its dependencies


  • Decouple an abstract specification from any particular implementation
  • Enable late and dynamic binding between components
  • Specify collaborations using interfaces and contracts
  • Enable substitution of different implementations
  • Enable reuse of implementations among different clients


  • Encapsulate a service request as an object
  • Parameterize methods for consistency
  • Dynamically specify and sequence methods with structure
  • Reduce complexity of code by reducing branching logic
  • Specify flexible workflows as data structures
  • Maintain action history
  • Implement 'Undo'


  • Dynamically augment an object’s behavior
  • Aggregate several effects into a single behavior
  • Replace complicated branching logic with flexible data structures
  • Encapsulate behavioral variations behind a unified interface

Dependency Injection

  • Maintain loose coupling between a component and its dependencies
  • Re-assign responsibility for object instantiation
  • Inject flexibility into the design
  • Simplify testing

Factory Method

  • Create polymorphic methods for object creation
  • Delegate responsibility for object construction
  • Isolate instantiation logic
  • Enable 'pre-packaged' default configurations
  • Reduce coupling to rigid constructor methods
  • Afford interface variation while maintaining implementation consistency


  • Inject new behavior without altering the interface
  • Encapsulate 'orthogonal' behavior
  • Encapsulate 'non-functional' enhancements and optimizations
  • Robustly utilize remote services


  • Simplify implementation of a state machine
  • Allow objects to respond differently according to internal state
  • Allow responsibilities and states to evolve with minimal effort
  • Reduce branching logic
  • Reduce number of components required to perform a service


  • Isolate changeable characteristics to avoid combinatorial explosion of configurations
  • Interchange behaviors among components
  • Increase cohesion by delegating specific responsibilities
  • Allow configurations to evolve with minimal effort
  • Reduce cost of testing

Template Method

  • Fix a sequence of behaviors while allowing each step to vary
  • Allow alternate algorithms to conform to the same contract
  • Enforce constraints in one place
  • Simplify verification of behavior

What are the requirements?

  • Attendees should have a basic understanding of object oriented software and be able to read Java, C++, or C# code.

What am I going to get from this course?

  • You will learn how to use specific design patterns to improve your designs.

Who is the target audience?

  • This seminar will benefit programmers, designers, technical leads, and anyone who needs to learn how to apply design patterns in modern software development projects.

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.


Section 1: Abstract Factory
Abstract Factory
Section 2: Adapter Pattern
Introduction to Adapter Pattern
Adapter Pattern - Pattern Structure
Code Implementation
Section 3: Bridge Pattern
Introduction and Code Implementation
Pattern Structure
Section 4: Command Pattern
Introduction and Pattern Structure
Code Implementation
Section 5: Decorator Pattern
Pattern Structure
Code Implementation
Section 6: Dependency Injection
Introduction and Code Implementation
Section 7: Factory Method
Introduction and Pattern Structure
Section 8: Proxy Pattern
Pattern Structure
Code Implementation
Section 9: State Pattern
Introduction and Code Capture
Pattern Structure
Section 10: Strategy Pattern
Introduction and Pattern Structure
Code Implementation
Section 11: Template Method
Pattern Structure
Code Implementation

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Construx Software, Software Development Best Practices

Construx Software provides world-class training and consulting in software development best practices. Construx’s CEO and founder, Steve McConnell, is the author of Code Complete, one of the most accessible books on software development ever written. Construx’s team of seasoned trailers and consultants has helped hundreds of companies solve their software challenges by identifying and adopting practices that have been proven to produce high quality software faster -- and with greater predictability.

Ready to start learning?
Take This Course