Design Patterns in Java: Behavioral

The Gang of Four Design Patterns explained and implemented using Java.
Course info
Rating
(106)
Level
Intermediate
Updated
Mar 9, 2016
Duration
4h 1m
Table of contents
Course Overview
Behavioral Design Patterns Introduction
Chain of Responsibility Pattern
Command Pattern
Interpreter Pattern
Iterator Pattern
Mediator Pattern
Memento Pattern
Observer Pattern
State Pattern
Strategy Pattern
Template Method Pattern
Visitor Pattern
What Next?
Description
Course info
Rating
(106)
Level
Intermediate
Updated
Mar 9, 2016
Duration
4h 1m
Description

This course is part of a 3 part series covering design patterns using Java. This part covers the behavioral design patterns, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template, and Visitor as defined by the Gang of Four. We look at examples in the Java API and code examples of each pattern.

About the author
About the author

Bryan is a Director at Software Technology Group, a consulting company based out of Salt Lake City, and has authored and taught numerous courses in Java.

More from the author
What’s New in Spring 5
Intermediate
1h 25m
31 Jan 2018
Building Applications Using Spring JDBC
Intermediate
2h 33m
27 Apr 2017
More courses by Bryan Hansen
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
(music) Hi everyone my name is Bryan Hansen. And welcome to my course design patterns in Java Behavioral. I'm the director of development and software technology group as we'll as the Pluralsight author. I learned about design patterns almost 20years ago and I've enjoyed teaching and sharing them with people ever since. In this course we are going to cover the behavioral patterns as identified by the gang of four. The gang of four are considered to be the father of design patterns as we know them today Some of the patterns we'll cover include ones that you may have already heard of like the Command Pattern which is used to isolate individual commands in your application. The Observer pattern which you'll use in a published subscribe event model In the Template method which you may already use more than you actually realize. This are just a few of the patterns that we will cover in this course and by the end of the course you will have seen an example of each pattern from the Java API. Reading each pattern from scratch and contrasted each pattern with another one to showcase its strengths. Before beginning this course you should be somewhat familiar with Java. And comfortable using an IDE. You can continue your running by exploring other patterns courses focused on creational in structural design patterns in the Pluralsight library. I hope you join me on this journey to learn this Design Patterns with the design patterns in Java behavioral course at Pluralsight. (fading theme music)

Behavioral Design Patterns Introduction
So you've just been in an interview and someone asked you to describe a design pattern. Or maybe you were just describing a problem to a co-worker and they said it sounds like you're reinventing the wheel. They might have even said to you that it sounds like you're describing a factory or a singleton pattern. If this sounds like a situation that you've been in, then this course is for you. Our focus in this course is on presenting the design patterns described in the gang of four in an example-driven way while using Java to do so. Hi, I'm Bryan Hansen, and welcome to Behavioral Design Patterns Using Java.

Chain of Responsibility Pattern
Hi, this is Bryan Hansen, and in this module we are going to look at the chain of responsibility design pattern. The chain of responsibility pattern is a behavioral pattern that decouples a request from a handling object in a chain of handlers until it is finally recognized.

Command Pattern
Hi this is Bryan Hansen And in this module we're going to look at the Command Design Patterns. The command pattern is a Behavioral Pattern that lets you encapsulate each request as an object. There are a lot of reasons to why you'll want to do this let's look at some of those concepts.

Interpreter Pattern
Hi, this is Bryan Hansen, and in this module we're going to look at the Interpreter design pattern. The Interpreter pattern is a behavioral pattern that you use to represent the grammar of a language. A lot of tools use this pattern when parsing various aspects of a grammar. Let's look at some of the concepts considered when choosing this pattern.

Iterator Pattern
Hi, this is Bryan Hansen. And in this module we're going to look at the iterator design pattern. The iterator pattern is a great pattern for providing navigation without exposing the structure of an object.

Mediator Pattern
Hi, this is Brian Hansen. And in this module, we are going to look at the Mediator design pattern. The Mediator pattern is used to define how objects interact with one another without having them refer to each other explicitly. Let's look at the concepts when choosing this pattern.

Memento Pattern
Hi, this is Bryan Hansen, and in this module we are going to look at the Memento design pattern. The Memento pattern is used to externalize an object's state, usually to provide rollback functionality.

Observer Pattern
Hi, this is Bryan Hansen, and in this module we are going to look at the Observer Design Pattern. The Observer Pattern is a decoupling pattern when we have a subject that needs to be observed by one or more observers. Let's look at the considerations when choosing this pattern.

State Pattern
Hi, this is Bryan Hansen, and in this module we are going to look at the State design pattern. The State pattern is, as it sounds, used when we need to represent State in an application.

Strategy Pattern
Hi, this is Bryan Hansen. And in this module, we are going to look at the strategy design pattern. The strategy pattern is a behavior pattern that is used when you want to enable the strategy or algorithm to be selected at run time. Let's look at the concepts when choosing this pattern.

Template Method Pattern
Hi, this is Bryan Hansen. And in this module, we're going to look at the template method design pattern. The template method pattern is used to define an algorithm that allows sub-classes to redefine parts of the algorithm without changing its structure. Let's look at the concepts as to why you would choose this pattern.

Visitor Pattern
Hi, this is Bryan Hansen, and in this module, we are going to look at the Visitor design pattern. The Visitor pattern is a great way to separate an algorithm from an object structure. Let's look at the concepts when choosing this pattern.

What Next?
Well, if you're seeing this slide, you've made it through the Design Patterns Behavioral course. And I want to thank you for staying with me through the whole thing. If you're wondering what to look for next, if you haven't already taken the first two parts of this course, the Design Patterns in Java: Creational course, and the Design Patterns in Java: Structural course, I would definitely recommend watching both of those videos to see the other counterparts of the three groups of patterns from the Gang of Four design patterns. Some of my other popular courses are Maven Fundamentals, Spring Fundamentals, Introduction to Spring MVC, and Introduction to Spring MVC 4. Those do build on top of one another; so I would recommend watching the Spring MVC one, first, and Spring MVC 4 one, next. And then, Spring with JPA and Hibernate, and, finally, Spring Security Fundamentals. And I'm also open and would like to hear feedback from you on other courses that you would like to see. You can reach out to me on my Twitter-handle, or my LinkedIn profile that are at the beginning of each slide. Thanks, again.