MyPage is a personalized page based on your interests.The page is customized to help you to find content that matters you the most.


I'm not curious

Foundations of Programming: Design Patterns

Course Summary

Identifies seven object-oriented design patterns (including the singleton, observer, decorator, and factory patterns) that make your development process faster and easier.         


  • +

    Course Syllabus


        Introduction
            Welcome
            What you should know before watching this course
            Using the exercise files
        1. Design Patterns
            Understanding the need for design patterns
            What are design patterns?
            Using design patterns
        2. The Strategy Pattern
            Understanding the pitfalls of inheritance and interfaces
            Encapsulating code that varies
            Programming to an interface
            Setting behavior dynamically
            Exploring the strategy pattern
            Understanding why HAS-A is better than IS-A
        3. The Observer Pattern
            Using the observer pattern in the real world
            Exploring the observer pattern
            Understanding the observer pattern
            Implementing the observer pattern
            Using Java's Observer and Observable classes
            Implementing the observer pattern with Java's Observer and Observable classes
            The advantages of loose coupling
        4. The Decorator Pattern
            Creating chaos with inheritance
            Understanding the open-closed principle
            Extending behavior with composition
            Understanding the decorator pattern
            Implementing the decorator pattern
            Understanding decorators in Java libraries
            Using java.io decorators
        5. The Singleton Pattern
            What is the singleton pattern?
            Understanding the classic singleton pattern
            Implementing the classic singleton pattern
            Dealing with multithreading
            Improving the singleton pattern implementation
        6. The State Pattern
            What is a state machine?
            Revisiting the design for a state machine
            Understanding the state pattern
            Implementing the state pattern
            Comparing the state and strategy patterns
       7. The Collection Pattern
            Encapsulating iteration
            Exploring the iterator pattern
            Implementing the iterator pattern
            Using Java's built-in iterators
            Implementing with Java's built-in iterators
            Making sure classes have only one responsibility
        8. Factories
            Encapsulating object creation
            Understanding the Simple Factory idiom
            Implementing the Simple Factory idiom
            Exploring the factory method pattern
            Implementing the factory method pattern
        Conclusion
             Looking at what we've done and where to go from here
            Additional resources

     


Course Fee:
USD 25

Course Type:

Self-Study

Course Status:

Active

Workload:

3 - 4 hours / week

This course is listed under Development & Implementations Community

Related Posts:

Attended this course?

Back to Top

Awards & Accolades for MyTechLogy
Winner of
REDHERRING
Top 100 Asia
Finalist at SiTF Awards 2014 under the category Best Social & Community Product
Finalist at HR Vendor of the Year 2015 Awards under the category Best Learning Management System
Finalist at HR Vendor of the Year 2015 Awards under the category Best Talent Management Software
Hidden Image Url

Back to Top