Object-Oriented Programming and Design

  1. Design Patterns
    1. Introduction to Design Patterns
      1. Purpose and Benefits
        1. Reusability and Maintainability
        2. Pattern Structure
          1. Problem
            1. Context
              1. Solution
                1. Consequences
              2. Creational Patterns
                1. Singleton Pattern
                  1. Ensuring Single Instance
                    1. Thread Safety Considerations
                    2. Factory Method Pattern
                      1. Defining Interface for Object Creation
                      2. Abstract Factory Pattern
                      3. Builder Pattern
                        1. Constructing Complex Objects Step by Step
                        2. Prototype Pattern
                          1. Cloning Existing Objects
                        3. Structural Patterns
                          1. Adapter Pattern
                            1. Converting Interfaces
                            2. Bridge Pattern
                              1. Decoupling Abstraction from Implementation
                              2. Composite Pattern
                                1. Tree Structures for Part-Whole Hierarchies
                                2. Decorator Pattern
                                  1. Adding Responsibilities Dynamically
                                  2. Facade Pattern
                                    1. Simplifying Complex Subsystems
                                    2. Flyweight Pattern
                                      1. Sharing Common State
                                      2. Proxy Pattern
                                        1. Controlling Access to Objects
                                      3. Behavioral Patterns
                                        1. Chain of Responsibility Pattern
                                          1. Passing Requests Along Chain
                                          2. Command Pattern
                                            1. Encapsulating Requests as Objects
                                            2. Interpreter Pattern
                                              1. Defining Grammar for Interpreting Expressions
                                              2. Iterator Pattern
                                                1. Sequential Access to Elements
                                                2. Mediator Pattern
                                                  1. Centralizing Complex Communications
                                                  2. Memento Pattern
                                                    1. Capturing and Restoring Object State
                                                    2. Observer Pattern
                                                      1. Notifying Dependent Objects of Changes
                                                      2. State Pattern
                                                        1. Altering Behavior When State Changes
                                                        2. Strategy Pattern
                                                          1. Encapsulating Algorithms
                                                          2. Template Method Pattern
                                                            1. Defining Skeleton of Algorithm
                                                            2. Visitor Pattern
                                                              1. Separating Operations from Object Structure

                                                          Previous

                                                          6. Principles of Object-Oriented Design

                                                          Go to top

                                                          Next

                                                          8. Object-Oriented Analysis and Modeling