Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Experience Design Patterns In Java to your Wishlist.

Add to Wishlist

Experience Design Patterns In Java

Learn to write better software by understanding common problems and applying design patterns for a better solution.
Bestselling
4.4 (332 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.
6,221 students enrolled
Last updated 10/2015
English English
$10 $95 89% off
3 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 7.5 hours on-demand video
  • 1 Article
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
Description

Boost your software designs by taking this content-rich and hands on fully featured training course.

This course will give you insight in the more than 20+ design patterns from the book "Design Patterns: Elements of Reusable Object-Oriented Software", by Gamma, Helm, Johnson and Vlissides, which is considered the reference on the subject.

For each pattern a clear example is given to understand the problem the pattern will solve, as well as its advantages and disadvantages. You will be able to practically understand how the pattern works with the detailed included Java lessons.

At the end of this course, you will be able to

  • Identify common problems in your code
  • Apply the correct design pattern
  • Talk with colleagues using a common vocabulary (and be a hero)
  • Implement a better object oriented solution that is a lot more maintainable and readable

- All of the video lectures are download-enabled.
If you have a slow internet connection, or want to take this course with you on your laptop, smartphone or other portable device, sign up and download all the videos and other course materials now.

Sign up now to get lifetime access to this course. With Udemy's 30-day money-back guarantee, it's risk-free.

Who is the target audience?
  • Software engineers
  • Designers
  • Architects
Students Who Viewed This Course Also Viewed
What Will I Learn?
Write better programs
Identify design problems
Learn the industry standard common vocabulary
View Curriculum
Requirements
  • Knowledge of object oriented programming
  • Basic understanding of UML
  • Experience in Java for the practical sessions
  • An open mind
Curriculum For This Course
Expand All 57 Lectures Collapse All 57 Lectures 07:45:05
+
Introduction
2 Lectures 14:37

What are design patterns and why should you care? In this introduction i'll give you an overview off all the things you need to know before starting this course.

Preview 14:35

Source code
00:02
+
Case Study: Building a 3D editor
5 Lectures 50:17

In the case study we'll look at a real life scenario where we can apply several design patterns.

Case Study
17:09

To build our 3D editor, we must define a correct document or data structure. In this practical Java session we'll go through the different options of defining that structure and how we can implementing it.

Case Study: Defining document structure
07:56

Let's look at the way we can render our images in the 3D editor, which are the main problems we must solve and how we can practically solve them using a strategy pattern. In this hands on session we will practically build our mini rendering program.

Case Study: Rendering strategy
04:15

How can we efficiently capture user action in the 3D editor? In this session we'll create a system that implements the command pattern to capture user actions.

Case Study: User interaction
07:26

We face an issue when we want to deploy our 3D editor on multiple operating systems. In this session we'll implement a system that reduces the complexity of the extra platforms by using the Bridge pattern.

Case Study: Multi platform
13:31
+
Creational Design Patterns
11 Lectures 01:14:40

In this lecture we'll discuss the focus points of the creational patterns and walk through the five patterns which are described in the "Gang of four: Elements of re-usable design" book.

Introduction
02:11

In this lecture we'll describe the problem of a complex system that can benefit from the singleton pattern. We'll explain the theory behind the singleton pattern: when can we use it, what does it solve and the different options of implementing it.

Preview 04:45

How can you abstract a complex system? In this lecture we'll practically handle the case of a billing system and improve the overall design by using the singleton pattern.

Preview 09:29

Image you have an application which connects to three different databases. How can you avoid duplicating code when you want to query all three of them?

Builder pattern
08:57

In this Java session we'll program the example given in the builder pattern theory. We'll create a fictional program that connects to three different databases. After this session the practical implication of the builder pattern will be clear.

Builder pattern using Java
07:44

In this lecture we'll discuss how the the factory method can delegate the object creation to other classes. We'll see how this pattern can improve our design when creating a re-usable framework.

Factory method pattern
05:48

With this hands on session we'll create a framework that relies on the factory method for object creation.

Factory method pattern using Java
05:56

In the Abstract Factory lecture, a case is brought to support an application with multiple themes. By this illustration it'll be clear when you can use it and how it can improve the overall design.

Abstract factory pattern
06:02

How can we support an application that support multiple themes? In this lecture we'll build this framework in Java, illustrate some problems and fix it with the abstract factory pattern.

Abstract factory using Java
07:23

The prototype pattern creates objects by cloning others. What this exactly means will be explained in this lecture.

Prototype pattern
05:54

Prototype pattern using Java
10:31

This quiz presents a number of design problems and to goal is to choose which creational pattern will solve them.

Creational Patterns Quiz
4 questions
+
Structural Design Patterns
15 Lectures 01:43:08

In this lecture we'll discuss the focus points of the structural patterns and walk through the seven patterns which are described in the "Gang of four: Elements of re-usable design" book.

Introduction
03:48

With the façade pattern we'll see how a complex system can be abstracted by using a façade. A complex financial system is given as an illustration to comprehend how the façade pattern can enlighten the overall design.

Façade pattern
05:12

This session shows how easy it can be to use a façade pattern to hide a complex system. We will program a fictional financial system and use the façade pattern to abstract it.

Façade pattern using Java
08:36

Ever wanted to use a class from another framework, but were faced with incompatible interfaces? In this lecture we'll discuss this problem and how the adapter pattern provides an elegant solution.

Adapter pattern
06:14

In this practical session we'll do a little geometry. We'll program a rectangle adapter to be able to adapt from the old to the new geometry classes.

Adapter pattern using Java
04:31

The decorator pattern works great when building user interface design. In this lecture we'll discuss an example when the decorator pattern really pays off. We'll also consider when to use this pattern and the main pros and cons.

Decorator pattern
07:16

In the hands on session of the decorator patten, we'll build a small GUI framework and improving it's design by using this pattern.

Decorator pattern using Java
10:13

This lecture handles the bridge pattern. We'll discuss how the bridge pattern can improve the overall design based on loose coupling an interface from its implementation.

Bridge pattern
05:51

Bridge pattern using Java
08:26

Sometimes it's necessary for a client to uniformly treat tree objects. This lectures covers how the composite pattern helps to solve this issue.

Composite pattern
05:43

In this session we'll effectively build a tree based on graphic objects. We apply the composite pattern so clients can simplify their code.

Composite pattern using Java
09:36

In this lecture we'll discuss the case where we want to dynamically load images of an application. We go through the various points where the proxy pattern comes in handy.

Proxy pattern
04:52

It's time to dynamically load images. This hands on session covers how the proxy pattern can be used to remain the overall code by adding dynamic behaviour to the application.

Proxy pattern using Java
10:48

Ever having an issue where your application is slow because it uses too much memory for thousand of objects? The flyweight pattern allows you to reuse these objects and gain a drastic performance improvement.

Flyweight pattern
04:21

In this hands on session, we'll build a small word process to illustrate how the flyweight pattern really improves the overall memory performance of an application.

Flyweight pattern using Java
07:41
+
Behavioral Design Patterns
19 Lectures 02:45:39

In this lecture we'll discuss the focus points of the behavioral patterns and walk through the eleven patterns which are described in the "Gang of four: Elements of re-usable design" book.

Introduction
03:22

This lecture illustrates how the command pattern really captures user or system actions. When should we apply this pattern and what are the pros and cons, it can all be found in this session.

Command pattern
05:53

Command pattern using Java
13:47

By using the strategy pattern we can encapsulate an algorithm in an object. We'll discuss a sample chess application that that benefits from applying the strategy pattern.

Strategy pattern
05:58

It's time to implement the strategy pattern in a fictional chess application.

Strategy pattern using Java
10:56

Visitor pattern
11:23

Visitor pattern using Java
13:09

Observer pattern
06:28

Observer pattern using Java
07:16

Memento pattern
07:07

Memento pattern using Java
14:09

Mediator pattern
06:32

Mediator pattern using Java
12:19

Chain of responsibility pattern
04:59

Chain of responsibility pattern using Java
07:38

State pattern
06:32

State pattern using Java
18:54

Template method pattern
04:13

Template method pattern using Java
05:04
+
Additional Patterns
4 Lectures 30:44

In this chapter we're going to discuss the inversion of control pattern. We'll start with a problem statement and move our way to the patten details.

Inversion of control pattern
10:19

Inversion Of control pattern using Java
07:47

What is a Transfer object? When is it interesting to use one? Learn all about it in this chapter.

Data transfer object pattern
06:01

Data transfer object using Java
06:37
+
Additional Materials
1 Lecture 00:00
Patterns Overview
26 pages
About the Instructor
4.4 Average rating
332 Reviews
6,396 Students
2 Courses
Software Architect Trainer

My professional career started ten years ago when I graduated from the university of Ghent (Belgium) with a masters degree in computer science. During my eduction I've always had a strong focus on software development.

Thus I started working as a technical consultant and gained experience as a software engineer in several large scale applications. My technical expertise was greatly appreciated. Part of my job description became guiding and training others where needed.

After a set of successful projects, I've received the opportunity to become a solution architect. With this change I've become more focused on how systems work together to fulfil a set of functionality instead of designing for one system in particular.

Teaching and supporting others in doing their job has always been a big part of my life. Therefore I possess the necessary skills to help others learn and focus on what's important.

Get the latest news @ElqooHome

Report Abuse