Implementing Design Patterns Using Java 8 Lambda

Focused View

Jose Paumard

3:08:19

49 View

00. Course Overview

00. Course Overview.mp4

01:39

01. Introducing Default Methods to Chain and Compose Functions

00. Introducing the Course - Designing API with Functional Interfaces.mp4

01:42

01. Who Are You - What Should You Know to Follow this Course - .mp4

02:18

02. Introducing the Agenda of the Course and This Module.mp4

01:47

03. Creating Default Methods to Chain Consumers as Lambda Expressions.mp4

05:37

04. Implementing the Consumer.andThen Method to Chain Consumers.mp4

02:15

05. Preventing the Chaining of Corrupted Lambdas Using Exceptions.mp4

02:38

06. Wrapping up the Use of Default Methods to Chain Lamdbas.mp4

00:57

07. Leveraging Default Methods to Combine Predicates.mp4

03:37

08. Implementing the Predicate.and Logical Operator.mp4

02:46

09. Negating a Predicate with a Predicate.negate Default Method.mp4

02:33

10. Wrapping up the Use of Default Methods to Combine Lamdbas.mp4

00:51

11. Setting up the Generic Types of a Chained Function.mp4

04:51

12. Implementing the Chaining of Functions with Default Methods.mp4

01:57

13. Understanding the Difference between Chaining and Composing.mp4

04:12

14. Using Static Methods on Functional Interfaces to Create Lambdas.mp4

01:30

15. Checking the Real Functional Interfaces from the JDK.mp4

01:40

16. Module Wrap Up.mp4

02:39

02. Using Function Composition and Chaining to Build Comparators

00. Introducing the Module and Its Agenda.mp4

01:36

01. Writing a Comparator of Person Comparing Their Names.mp4

04:28

02. Creating a Factory Method of Comparators Using a Key Extractor.mp4

03:09

03. Reversing a Comparator with the User of a Default Method.mp4

02:12

04. Making the Factory Method Generic to Accept Any Comparable Object.mp4

03:34

05. Wrapping up the Creation of Comparators Using Key Extractors.mp4

01:23

06. Leveraging Default Methods to Combine Comparators.mp4

04:35

07. Improving the Design of the API to Make It Fluent.mp4

02:42

08. Checking the Real Comparator Interface from the JDK.mp4

01:27

09. Module Wrap Up.mp4

02:30

03. From Factory and Registry to Builder Using Lambda Expressions

00. Introducing the Module and Its Agenda.mp4

01:32

01. Creating a Factory by Extending the Supplier Functional Interface.mp4

04:38

02. Adding Functionalities to a Factory Using Default Methods.mp4

02:24

03. Extending the Factory to Handle Constructor with Parameters.mp4

03:40

04. Making the Factory Fluent Using Generics and Method References.mp4

05:15

05. Updating the Factory to Implement the Singleton Pattern.mp4

01:22

06. Wrapping up the Factory and Singleton Patterns Using Lambdas.mp4

01:41

07. Introducing the Registry and the Builder Pattern.mp4

02:37

08. Designing an API to Create a Registry Using the Builder Pattern.mp4

02:54

09. Introducing the Registry and the Builder Examples.mp4

02:04

10. Writing the Registration of a Factory Using a Consumer of Builder.mp4

06:27

11. Making the Registry Functional to Implement It Using a Lambda.mp4

02:11

12. Testing the Registry to Create Different Kind of Shapes.mp4

02:04

13. Controlling Missing Keys with Exceptions Defined at the API Level.mp4

05:11

14. Wrapping up the Registry and Builder Built with Lambda Example.mp4

01:11

15. Module Wrap Up.mp4

01:40

04. Implementing The Visitor Pattern Using Functions and Composition

00. Introducing the Module and Its Agenda.mp4

01:09

01. Adding Operations on Classes Using the Visitor Pattern.mp4

01:45

02. Organizing a Simple Object Model to Implement the Visitor Pattern.mp4

01:58

03. Writing a Visitable Set of Classes along with a Visitor.mp4

02:26

04. Adding Methods on a Class without Changing It Using Lambdas.mp4

01:14

05. Writing the Lambda Visitor Pattern on the Car Model Object.mp4

03:09

06. Adding the Static and Default Methods for the Pattern to Compile.mp4

02:54

07. Implementing the Registry of Types to Be Visited and Functions.mp4

02:48

08. Running the Pattern with the Initialized Registry.mp4

03:25

09. Adding a Second Element to the Registry - A First Version.mp4

04:12

10. Fixing the Multi Element Registry with the Chaining of Consumers.mp4

06:35

11. Making this Visitor Pattern Type Safe Using Gnerics.mp4

07:31

12. Module Wrap Up.mp4

02:12

05. Using Partial Application and Lambdas to Build Validators

00. Introducing the Module and Its Agenda.mp4

01:17

01. Setting up a Person Bean with Two Validation Rules.mp4

01:58

02. Understanding the Validation Rules and Setting up Examples.mp4

02:23

03. Writing the Validator Pattern in the Case of a Person Bean.mp4

02:22

04. Implementing the Validator Interface in the Case of a Valid Bean.mp4

03:11

05. Extending the Validator to Handle One Violated Rule.mp4

02:09

06. Introducing the SuppressedExceptions to Wrap Exceptions Together.mp4

03:03

07. Handling Several Exceptions with the Suppressed Exceptions.mp4

06:48

08. Module and Course Wrap Up.mp4

03:54

Description

Being able to design simple and fluent API to make your business applications easier to read is what you will get by following this course. All the tools brought by Java 8 to implement the standard Design Patterns are covered with many live demos.

What You'll Learn?

As a Java developer, mastering the standard design patterns from the Gang of Four book allows you to create better business applications, more robust and easier to maintain in the long run. In this course, Implementing Design Patterns Using Java 8 Lambda, you will learn how you can leverage the tools Java 8 added to the platform to write better code: easier to read and with better performances. These tools bring several functional programming paradigms to the Java language: function chaining and composition, and partial application. First, you will study how these tools have been used to improve the JDK itself through several examples including the Comparator API. Then you will see how you can use the same approach to implement several patterns on live demo examples, including the Factory, the Builder, the Singleton, and the Registry, following the principles of clean code. You will even implement the Visitor pattern in a functional and non-intrusive way. Finally, you will apply those principles to create your own Validator, purely functional and fluent. Mastering these techniques will help you creating performant, readable and versatile Java applications.

More details

User Reviews

Rating

average 0

Total votes0

Focused display

Java

Jose Paumard

Instructor's Courses

Passionate about programming computers for over 20 years, Jose made his debut in assembler and C, C for SIMD parallel machines before adopting Java as an object-oriented language, indispensable to most major modern applications. He brings his expertise and capacity for analysis and synthesis to many projects, mainly in the lower layers, close to the data, but also on complex UI design, or in the browser. PhD in applied maths and computer science, assistant professor in Paris North University for 15 years, Jose also has a passion for education and knowledge transfer. He writes a blog, Java le soir, French documentary source on Java technologies for thousands of french speaking developers around the world. He is a member of the french Paris Java User Group, and co-organizer of the conference Devoxx France.

Pluralsight

View courses Pluralsight

Pluralsight, LLC is an American privately held online education company that offers a variety of video training courses for software developers, IT administrators, and creative professionals through its website. Founded in 2004 by Aaron Skonnard, Keith Brown, Fritz Onion, and Bill Williams, the company has its headquarters in Farmington, Utah. As of July 2018, it uses more than 1,400 subject-matter experts as authors, and offers more than 7,000 courses in its catalog. Since first moving its courses online in 2007, the company has expanded, developing a full enterprise platform, and adding skills assessment modules.