Learning PHP Design Patterns

Kup polskie wydanie:

Spis treści ebooka

• Learning PHP Design Patterns
• Dedication
• Preface
  • Audience
  • Assumptions This Book Makes
  • Contents of This Book
  • Conventions Used in This Book
  • Using Code Examples
  • Safari Books Online
  • How to Contact Us
  • Acknowledgments
• I. Easing into the Fundamentals of Design Patterns
  • 1. PHP and Object-Oriented Programming
    • Entering into Intermediate and Advanced Programming
    • Why Object-Oriented Programming?
      • Making Problem Solving Easier
      • Modularization
    • Classes and Objects
      • Single Responsibility Principle
      • Constructor Functions in PHP
    • The Client as a Requester Class
    • What About Speed?
      • The Speed of Development and Change
      • The Speed of Teams
    • Whats Wrong with Sequential and Procedural Programming?
      • Sequential Programming
      • Procedural Programming
      • Pay Me Now or Pay Me Later
  • 2. Basic Concepts in OOP
    • Abstraction
      • Abstract Classes
      • Abstract Properties and Methods
      • Interfaces
      • Interfaces and Constants
      • Type Hinting: Almost Data Typing
    • Encapsulation
      • Everyday Encapsulation
      • Protecting Encapsulation through Visibility
        • Private
        • Protected
        • Public
      • Getters and Setters
    • Inheritance
    • Polymorphism
      • One Name with Many Implementations
      • Built-In Polymorphism in Design Patterns
    • Easy Does It
  • 3. Basic Design Pattern Concepts
    • The MVC Loosens and Refocuses Programming
    • Basic Principles of Design Patterns
      • The First Design Pattern Principle
      • Using Interface Data Types in Code Hinting
      • Abstract Classes and Their Interfaces
      • The Second Design Pattern Principle
      • Basic Composition Using a Client
      • Delegation: The IS-A and HAS-A Difference
    • Design Patterns as a Big Cheat Sheet
      • Organization of Design Patterns
        • Creational patterns
        • Structural patterns
        • Behavioral patterns
        • Class category
        • Object category
    • Choosing a Design Pattern
      • What Causes Redesign?
      • What Varies?
      • What Is the Difference Between Design Patterns and Frameworks?
  • 4. Using UMLs with Design Patterns
    • Why Unified Modeling Language (UML)?
    • Class Diagrams
    • Participant Symbols
    • Relationship Notations
      • Acquaintance Relations
      • Aggregation Relationship
      • Inheritance and Implementation Relations
      • Creates Relations
      • Multiple Relations
    • Object Diagrams
    • Interaction Diagrams
    • The Role of Diagrams and Notations in Object-Oriented Programming
    • Tools for UMLs
    • Other UMLs
• II. Creational Design Patterns
  • 5. Factory Method Design Pattern
    • What Is the Factory Method Pattern?
    • When to Use the Factory Method
    • A Minimalist Example
      • Factory Work
        • The Product
      • The Client
    • Accommodating Class Changes
      • Adding Graphic Elements
      • Coordinating Products
      • Changing the Text Product
      • Changing the Graphic Product
      • Adding New Products and Parameterized Requests
      • One Factory and Multiple Products
      • The New Factories
      • The New Products
      • The Client with Parameters
      • Helper Classes
      • File Diagram
      • Product Changes: Leave the Interface Alone!
  • 6. Prototype Design Pattern
    • What Is the Prototype Design Pattern?
    • When to Use the Prototype Pattern
    • The Clone Function
      • Constructor Does Not Relaunch with Clone
      • The Constructor Function Should Do No Real Work
    • A Minimalist Prototype Example
      • Studying Fruit Flies
        • The abstract class interface and concrete implementation
        • The Client
    • Adding OOP to the Prototype
      • The Modern Business Organization
      • Encapsulation in the Interface
      • The Interface Implementations
      • The Organizational Client
      • Making Changes, Adding Features
      • Dynamic Object Instantiation
        • Variables to objects
    • The Prototype in PHP Land
• III. Structural Design Patterns
  • 7. The Adapter Pattern
    • What Is the Adapter Pattern?
    • When to Use the Adapter Pattern
    • The Adapter Pattern Using Inheritance
      • A Minimal Example of a Class Adapter: The Currency Exchange
        • Enter the euro
        • Creating a euro adapter
    • The Adapter Pattern Using Composition
      • From Desktop to Mobile
        • Just the desktop
          • Adapting to mobile
        • The Client class as participant
      • Adapters and Change
  • 8. Decorator Design Pattern
    • What Is the Decorator Pattern?
    • When to Use the Decorator Pattern
    • Minimalist Decorator
      • The Component Interface
      • The Decorator Interface
      • Concrete Component
      • Concrete Decorators
        • Maintenance
        • Video
        • Database
      • The Client
    • What About Wrappers?
      • Primitives in Wrappers
      • Built-in Wrappers in PHP
      • Design Pattern Wrappers
    • Decorators with Multiple Components
      • Multiple Concrete Components
      • Concrete Decorators with Multiple States and Values
      • The Developer Dating Service
        • Component interface
        • Concrete components
        • Decorator with component methods
        • Concrete decorators
        • The Client
    • HTML User Interface (UI)
      • The Client Class Passing HTML Data
      • From a Variable Name to an Object Instance
      • Adding a Decoration
• IV. Behavioral Design Patterns
  • 9. The Template Method Pattern
    • What Is the Template Method Pattern?
    • When to Use the Template Method
    • Using the Template Method with Images and Captions: A Minimal Example
      • The Abstract Class
      • The Concrete Class
    • The Client
    • The Hollywood Principle
    • Using the Template Method with Other Design Patterns
      • The Clients Reduced Workload
      • The Template Method Participants
    • The Factory Method Participants
    • The Hook in the Template Method Design Pattern
      • Setting Up the Hook
      • Implementing the Hook
      • The Client and Tripping the Hook
        • Setting the Boolean with comparison operators
        • The Client class
    • The Small and Mighty Template Method
  • 10. The State Design Pattern
    • What Is the State Pattern?
    • When to Use the State Pattern?
    • The State Machine
    • Light On, Light Off: The Minimal State Design Pattern
      • Context Is King
        • State instances in the Context class
        • Calling the state methods: Context trigger methods
        • Setting the current state
        • The state getters
        • The Context class summary
      • The States
        • OnState
        • OffState
      • The Client Request through the Context
    • Adding States
      • Changing the Interface
      • Changing the States
        • OffState
        • OnState
        • BrighterState
        • BrightestState
      • Updating the Context Class
      • An Updated Client
    • The Navigator: More Choices and Cells
      • Setting Up a Matrix Statechart
      • Setting Up the Interface
      • The Context
      • The States
        • Cell1State
        • Cell2State
        • Cell3State
        • Cell4State
        • Cell5State
        • Cell6State
        • Cell7State
        • Cell8State
        • Cell9State
      • The Client Picks a Path
    • The State Pattern and PHP
• V. MySQL and PHP Design Patterns
  • 11. A Universal Class for Connections and a Proxy Pattern for Security
    • A Simple Interface and Class for MySQL
      • The Pregnant Interface
      • Universal MySQL Connection Class and Static Variables
      • Easy Client
    • The Protection Proxy for Login
      • Setting Up Login Registration
      • Implementing the Login Proxy
        • The login form and the Client
        • The Proxy at work
        • The real subject
    • The Proxy and Real-World Security
  • 12. The Flexibility of the Strategy Design Pattern
    • Encapsulating Algorithms
      • Differentiating the Strategy from the State Design Pattern
      • No Conditional Statements, Please
      • A Family of Algorithms
    • A Minimalist Strategy Pattern
      • The Client and the Trigger Scripts
      • The Context Class and Strategy Interface
      • The Concrete Strategies
        • DataEntry
        • DisplayData
        • SearchData
        • UpdateData
        • DeleteRecord
        • Connection interface and class
    • Expanded Strategy Pattern with Data Security and Parameterized Algorithms
      • A Data Security Helper Class
      • Adding a Parameter to an Algorithm Method
      • The Survey Table
      • Data Entry Modules
      • The Client Calls for Help
      • The Minor but Major Change in Context Class
      • The Concrete Strategies
        • DataEntry
        • DisplayAll
        • SearchData
        • UpdateData
        • DeleteRecord
    • The Flexible Strategy Pattern
  • 13. The Chain of Responsibility Design Pattern
    • Passing the Buck
    • The Chain of Responsibility in a MySQL Help Desk
      • Building and Loading the Response Table
        • InsertData.php
        • UpdateData.php
      • The Help Desk Chain of Responsibility
        • HTML Data Entry, Client and Request Participants
        • Handler interface and concrete handlers
    • Automated Chain of Responsibility and Factory Method
      • The Chain of Responsibility and Date-Driven Requests
      • Factory Method Finishes Job
        • The Creator and HungerFactory
        • The product and individual countries
        • Helpers, resources, and style
    • Ease of Update
  • 14. Building a Multidevice CMS with the Observer Pattern
    • Built-In Observer Interfaces
    • When to Use the Observer Pattern
    • Using SPL with the Observer Pattern
      • SplSubject
      • SplObserver
      • SplObjectStorage
      • The SPL Concrete Subject
      • The SPL Concrete Observer
      • The SPL Client
    • Free Range PHP and the Observer Pattern
      • The Abstract Subject Class and ConcreteSubject Implementation
      • Observer and Multiple Concrete Observers
        • ConcreteObserverDT (Desktop implementation)
        • ConcreteObserverTablet (Tablet implementation)
        • ConcreteObserverPhone (Smartphone implementation)
      • The Client
    • Making a Simple CMS
      • CMS Utilities
        • CMS table
        • CMS data entry and update
      • The Multiple Device Observer
        • Two HTML UI documents
        • The sniffer client
        • The Subject classes
        • Multiple concrete observers
          • The mobile phone observer
          • Tablet observer
          • Desktop view
    • Thinking OOP
• Index
• About the Author
• Colophon
• Copyright

pokaż cały spis treści

ukryj recenzje