Design Patterns

Learn how to implement design patterns to make your software more efficient and powerful.
5.0 (1 rating) 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.
5 students enrolled
$50
Take This Course
  • Lectures 23
  • Contents Video: 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

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

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

Adapter

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

Bridge

  • 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

Command

  • 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'

Decorator

  • 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

Proxy

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

State

  • 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

Strategy

  • 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.

What 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.

Curriculum

Section 1: Abstract Factory
Abstract Factory
Preview
13:23
Section 2: Adapter Pattern
Introduction to Adapter Pattern
01:24
Adapter Pattern - Pattern Structure
06:36
Code Implementation
04:24
Section 3: Bridge Pattern
Introduction and Code Implementation
07:09
Pattern Structure
14:05
Section 4: Command Pattern
Introduction and Pattern Structure
05:25
Code Implementation
18:20
Section 5: Decorator Pattern
Introduction
Preview
01:58
Pattern Structure
Preview
04:06
Code Implementation
22:21
Section 6: Dependency Injection
Introduction and Code Implementation
05:56
Section 7: Factory Method
Introduction and Pattern Structure
18:34
Section 8: Proxy Pattern
Introduction
02:21
Pattern Structure
04:08
Code Implementation
02:12
Section 9: State Pattern
Introduction and Code Capture
04:23
Pattern Structure
14:38
Section 10: Strategy Pattern
Introduction and Pattern Structure
05:15
Code Implementation
11:57
Section 11: Template Method
Introduction
02:05
Pattern Structure
03:10
Code Implementation
14:16

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