Design Patterns, A Pragmatic Approach

It's a focussed, simple and practical look into the Gang of Four design patterns
4.3 (9 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.
95 students enrolled
$19
$20
5% off
Take This Course
  • Lectures 28
  • Length 3.5 hours
  • Skill Level Beginner 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 8/2015 English

Course Description

We take a pragmatic look at the Gang of Four design patterns with special focus on students being able to understand each pattern very quickly. To achieve this, I will keep it simple and only teach you what you need to know.

You say why do I need to learn design patterns? Well, solving software engineering problems is integral to your job as a software engineer, design patterns gives you a set of re-usable template for doing this.

Consider this scenario, you walk into an interview, the interviewer asks you to give examples of design patterns and how you have used them, you mention the 23 Gang of Four patterns from memory, you then describe in detail how and when to use them. That will be impressive. In this course, I will give you the formula to be able to do just that.

I start you off with the master quiz, use this to guage your understanding before and after the course.

This course focusses on the Gang of Four design pattern and clearly explains each pattern using the structure:

- Explanation

- Real World Example

- UML

- Code Example

- When to use/When not to use

This is followed by a memory exercise aimed at giving you a simple technique for remembering all Gang of Four design patterns from memory.

To take this course, you should be familiar with Object Oriented design. It will use UML and Java, so familiarity with these in particular will be helpful.

At the end of the course, students will be able to use design patterns to find solutions to recurring problems of system architecture. They will have personal practical experience of all Gang of Four design patterns, recognise them and can begin incorporating them into their own code.

OK, let's get started, please enjoy and let me take you on a learning journey.

What are the requirements?

  • To take this course, you should be familiar with object oriented design.

What am I going to get from this course?

  • At the end of the course, you will have a personal practical experience of all Gang of Four design patterns, recognise them and can begin incorporating them into your own code.

What is the target audience?

  • This course is aimed at software engineers.

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: Master Quiz
40 questions

40 Questions. Covers all sections of the course. This assessment will allow the students to guage their understanding of the course contents and provide useful feedback to the tutor.

Section 2: Introduction
01:40

Introducing the course

02:22

Format. After this section, you will will know the format of the course

Section 3: Design Patterns and Gang of Four
11:34

Design Patterns and Gang of Four - After this lecture, you will be able to define design patterns and know who the Gang of Four are!

Section 4: Deep Dive
12:40

Abstract Factory. After this lecture, you should be able to explain the abstract factory design pattern in simple terms and start incorporating it in your own code.

06:49

Builder. After this lecture, you should be able to explain the builder design pattern in simple terms and start incorporating it in your own code.

06:00

Factory methods. After this lecture, you should be able to explain the factory methods design pattern in simple terms and start incorporating it in your own code.

08:31

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

06:27

Singleton. After this lecture, you should be able to explain the singleton design pattern in simple terms and start incorporating it in your own code.

05:18

Adapter. After this lecture, you should be able to explain the adapter design pattern in simple terms and start incorporating it in your own code.

09:08

Bridge. After this lecture, you should be able to explain the bridge design pattern in simple terms and start incorporating it in your own code.

08:39

Composite. After this lecture, you should be able to explain the composite design pattern in simple terms and start incorporating it in your own code.

09:37

Decorator. After this lecture, you should be able to explain the decorator design pattern in simple terms and start incorporating it in your own code.

06:45

Facade. After this lecture, you should be able to explain the facade design pattern in simple terms and start incorporating it in your own code.

09:48

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

08:54

Flyweight. After this lecture, you should be able to explain the flyweight design pattern in simple terms and start incorporating it in your own code.

05:06

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

07:30

Command. After this lecture, you should be able to explain the command design pattern in simple terms and start incorporating it in your own code.

08:33

Iterator. After this lecture, you should be able to explain the iterator design pattern in simple terms and start incorporating it in your own code.

05:19

Interpreter. After this lecture, you should be able to explain the interpreter design pattern in simple terms and start incorporating it in your own code.

05:18

Mediator. After this lecture, you should be able to explain the mediator design pattern in simple terms and start incorporating it in your own code.

06:11

Memento. After this lecture, you should be able to explain the memento design pattern in simple terms and start incorporating it in your own code.

08:34

Observer. After this lecture, you should be able to explain the observer design pattern in simple terms and start incorporating it in your own code.

08:48

State. After this lecture, you should be able to explain the state design pattern in simple terms and start incorporating it in your own code.

07:21

Strategy. After this lecture, you should be able to explain the strategy design pattern in simple terms and start incorporating it in your own code.

05:49

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

06:29

Visitor. After this lecture, you should be able to explain the Visitor design pattern in simple terms and start incorporating it in your own code.

Section 5: Memory Exercise
03:49

Lets burn GOF into our heads! After this lecture, you should be able to remember all GOF patterns from memory.

Section 6: Non Gang of Four Patterns
08:37

Other Patterns. After this lecture, you will know some other non-GOF design patterns, some of which are widely used today.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Peter Fajemisin, Software Consultant and Trainer

I am an Agile Java developer with over 10 years experience of developing a wide variety of enterprise applications.

I have a passion for learning technology and I actively follow and participate in many technology communities.

Technical Expertise includes: Design Patterns, Scrum, XP, JavaEE, Spring, Maven, Ant, JBoss, Apache Tomcat, Oracle, MSSQL, Query Optimization, JPA, Hibernate, Spring, JavaEE, Wicket, JSF, Struts, Mockito, JBPM, Drools, Comet, SOA, REST, Web Services, F5 Load Balancer, JQuery, Ajax, Comet, Linux, Apache, Tomcat, JMeter, JProfiler, Adobe Day CQ, Jenkins, Git, Subversion, Ehcache and Terracotta, Selenium.

As a software trainer, I strongly believe in simplicity and pragmatism, I will not bore you with hours of lectures and I will keep each topic focussed and to the point.

To take a quote from Albert Einstein “If you can't explain it simply, you don't understand it well enough." To make sure you learn:

I will keep it simple stupid

I will only teach you what you need to know

So please have an open mind and allow me to take you on a learning journey.

Ready to start learning?
Take This Course