2014
Pluralsight
Mark Seemann
5h 9m
English
This course teaches how to write maintainable and flexible object-oriented code.
Learn how to write maintainable software that can easily respond to changing requirements using object-oriented design principles. First, you'll learn about the fundamental object-oriented design principle of Encapsulation, and then you'll learn about the five SOLID principles, also known as 'the principles of object-oriented design.' While this course is aimed at beginner to intermediate developers, it's based on decades of experience, so even advanced programmers can learn a thing or two. There are plenty of code examples along the way; while they're written in C#, they should be easily understandable to readers of Java or other curly-brace-based languages.
01. Course introduction 00:04:02
01. Introduction 04:02
02. Encapsulation 01:31:43
01. Introduction 00:28
02. Reusable Components 01:55
03. Most Code Sucks 01:22
04. Example: Code That Sucks 03:55
05. Why Care About Code That Sucks? 05:17
06. Classic OO Definition of Encapsulation 05:52
07. Alternative Encapsulation Techniques 03:56
08. Commands and Queries 08:08
09. Queries 04:07
10. Commands 04:14
11. CQS Makes it Easier to Reason About Code 01:15
12. Postel's Law 04:46
13. Input 05:31
14. Nullable References Are Evil 02:26
15. Fail Fast 03:19
16. Output 10:30
17. Tester/Doer 03:43
18. TryRead 04:56
19. Maybe 07:47
20. Synthesis 08:08
03. The Single Responsibility Principle 00:28:20
01. Introduction and Motivation 10:37
02. The Five SOLID Principles 03:34
03. Refactored Sample Problem Class 02:51
04. Single Responsibility Principle 11:18
04. The Open Closed Principle 00:22:35
01. SOLID Concrete 11:15
02. The Open Closed Principle 03:27
03. Refactoring the Example Code Towards the Open Closed Principle 07:52
05. The Liskov Substitution Principle 00:50:33
01. Append-Only 11:16
02. The Liskov Substitution Principle 04:14
03. Breaking the LSP: Removal of Features 08:11
04. Refactoring the Code Toward the Lisko Substitution Principle 26:50
06. The Interface Segregation Principle 00:27:13
01. SOLID Isn't 06:10
02. The Interface Segregation Principle 05:41
03. Refactoring the Code Toward the Interface Segregation Principle 04:54
04. Refactoring With ISP 10:26
07. The Dependency Inversion Principle 00:47:10
01. Next Step: Functional 08:36
02. Favor Composition Over Inheritance 02:25
03. Composite 04:53
04. Decorator 08:21
05. Refactoring the Read Example Method to a Decorator 12:14
06. Final Clean-Up 08:23
07. SOLID Summary 02:15
08. The Coffee Maker Code Example 00:38:21
01. Introduction to the Coffee Maker Code Example 01:49
02. Coffee Maker Problem Statement 02:20
03. Demo Introduction 00:40
04. Demo: Coffe Maker Example Implementation 31:52
05. Demo Recap 00:34
06. Course Conclusion 01:03
http://pluralsight.com/
Download File Size:1.02 GB
|
