book

Learning PHP Design Patterns

by William Sanders

February 2013

Intermediate to advanced

362 pages

8h 16m

English

O'Reilly Media, Inc.

Read now

Unlock full access

AudienceAssumptions This Book MakesContents of This BookConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgments
Entering into Intermediate and Advanced ProgrammingWhy Object-Oriented Programming?Making Problem Solving EasierModularizationClasses and ObjectsSingle Responsibility PrincipleConstructor Functions in PHPThe Client as a Requester ClassWhat About Speed?The Speed of Development and ChangeThe Speed of TeamsWhat’s Wrong with Sequential and Procedural Programming?Sequential ProgrammingProcedural ProgrammingPay Me Now or Pay Me Later
AbstractionAbstract ClassesAbstract Properties and MethodsInterfacesInterfaces and ConstantsType Hinting: Almost Data TypingEncapsulationEveryday EncapsulationProtecting Encapsulation through VisibilityPrivateProtectedPublicGetters and SettersInheritancePolymorphismOne Name with Many ImplementationsBuilt-In Polymorphism in Design PatternsEasy Does It
The MVC Loosens and Refocuses ProgrammingBasic Principles of Design PatternsThe First Design Pattern PrincipleUsing Interface Data Types in Code HintingAbstract Classes and Their InterfacesThe Second Design Pattern PrincipleBasic Composition Using a ClientDelegation: The IS-A and HAS-A DifferenceDesign Patterns as a Big Cheat SheetOrganization of Design PatternsCreational patternsStructural patternsBehavioral patternsClass categoryObject categoryChoosing a Design PatternWhat Causes Redesign?What Varies?What Is the Difference Between Design Patterns and Frameworks?
Why Unified Modeling Language (UML)?Class DiagramsParticipant SymbolsRelationship NotationsAcquaintance RelationsAggregation RelationshipInheritance and Implementation RelationsCreates RelationsMultiple RelationsObject DiagramsInteraction DiagramsThe Role of Diagrams and Notations in Object-Oriented ProgrammingTools for UMLsOther UMLs
What Is the Factory Method Pattern?When to Use the Factory MethodA Minimalist ExampleFactory WorkThe ProductThe ClientAccommodating Class ChangesAdding Graphic ElementsCoordinating ProductsChanging the Text ProductChanging the Graphic ProductAdding New Products and Parameterized RequestsOne Factory and Multiple ProductsThe New FactoriesThe New ProductsThe Client with ParametersHelper ClassesFile DiagramProduct Changes: Leave the Interface Alone!

What Is the Prototype Design Pattern?When to Use the Prototype PatternThe Clone FunctionConstructor Does Not Relaunch with CloneThe Constructor Function Should Do No Real WorkA Minimalist Prototype ExampleStudying Fruit FliesThe abstract class interface and concrete implementationThe ClientAdding OOP to the PrototypeThe Modern Business OrganizationEncapsulation in the InterfaceThe Interface ImplementationsThe Organizational ClientMaking Changes, Adding FeaturesDynamic Object InstantiationVariables to objectsThe Prototype in PHP Land
What Is the Adapter Pattern?When to Use the Adapter PatternThe Adapter Pattern Using InheritanceA Minimal Example of a Class Adapter: The Currency ExchangeEnter the euroCreating a euro adapterThe Adapter Pattern Using CompositionFrom Desktop to MobileJust the desktopAdapting to mobileThe Client class as participantAdapters and Change
What Is the Decorator Pattern?When to Use the Decorator PatternMinimalist DecoratorThe Component InterfaceThe Decorator InterfaceConcrete ComponentConcrete DecoratorsMaintenanceVideoDatabaseThe ClientWhat About Wrappers?Primitives in WrappersBuilt-in Wrappers in PHPDesign Pattern WrappersDecorators with Multiple ComponentsMultiple Concrete ComponentsConcrete Decorators with Multiple States and ValuesThe Developer Dating ServiceComponent interfaceConcrete componentsDecorator with component methodsConcrete decoratorsThe ClientHTML User Interface (UI)The Client Class Passing HTML DataFrom a Variable Name to an Object InstanceAdding a Decoration
What Is the Template Method Pattern?When to Use the Template MethodUsing the Template Method with Images and Captions: A Minimal ExampleThe Abstract ClassThe Concrete ClassThe ClientThe Hollywood PrincipleUsing the Template Method with Other Design PatternsThe Client’s Reduced WorkloadThe Template Method ParticipantsThe Factory Method ParticipantsThe Hook in the Template Method Design PatternSetting Up the HookImplementing the HookThe Client and Tripping the HookSetting the Boolean with comparison operatorsThe Client classThe Small and Mighty Template Method
What Is the State Pattern?When to Use the State Pattern?The State MachineLight On, Light Off: The Minimal State Design PatternContext Is KingState instances in the Context classCalling the state methods: Context trigger methodsSetting the current stateThe state gettersThe Context class summaryThe StatesOnStateOffStateThe Client Request through the ContextAdding StatesChanging the InterfaceChanging the StatesOffStateOnStateBrighterStateBrightestStateUpdating the Context ClassAn Updated ClientThe Navigator: More Choices and CellsSetting Up a Matrix StatechartSetting Up the InterfaceThe ContextThe StatesCell1StateCell2StateCell3StateCell4StateCell5StateCell6StateCell7StateCell8StateCell9StateThe Client Picks a PathThe State Pattern and PHP
A Simple Interface and Class for MySQLThe Pregnant InterfaceUniversal MySQL Connection Class and Static VariablesEasy ClientThe Protection Proxy for LoginSetting Up Login RegistrationImplementing the Login ProxyThe login form and the ClientThe Proxy at workThe real subjectThe Proxy and Real-World Security
Encapsulating AlgorithmsDifferentiating the Strategy from the State Design PatternNo Conditional Statements, PleaseA Family of AlgorithmsA Minimalist Strategy PatternThe Client and the Trigger ScriptsThe Context Class and Strategy InterfaceThe Concrete StrategiesDataEntryDisplayDataSearchDataUpdateDataDeleteRecordConnection interface and classExpanded Strategy Pattern with Data Security and Parameterized AlgorithmsA Data Security Helper ClassAdding a Parameter to an Algorithm MethodThe Survey TableData Entry ModulesThe Client Calls for HelpThe Minor but Major Change in Context ClassThe Concrete StrategiesDataEntryDisplayAllSearchDataUpdateDataDeleteRecordThe Flexible Strategy Pattern
Passing the BuckThe Chain of Responsibility in a MySQL Help DeskBuilding and Loading the Response TableInsertData.phpUpdateData.phpThe Help Desk Chain of ResponsibilityHTML Data Entry, Client and Request ParticipantsHandler interface and concrete handlersAutomated Chain of Responsibility and Factory MethodThe Chain of Responsibility and Date-Driven RequestsFactory Method Finishes JobThe Creator and HungerFactoryThe product and individual countriesHelpers, resources, and styleEase of Update
Built-In Observer InterfacesWhen to Use the Observer PatternUsing SPL with the Observer PatternSplSubjectSplObserverSplObjectStorageThe SPL Concrete SubjectThe SPL Concrete ObserverThe SPL ClientFree Range PHP and the Observer PatternThe Abstract Subject Class and ConcreteSubject ImplementationObserver and Multiple Concrete ObserversConcreteObserverDT (Desktop implementation)ConcreteObserverTablet (Tablet implementation)ConcreteObserverPhone (Smartphone implementation)The ClientMaking a Simple CMSCMS UtilitiesCMS tableCMS data entry and updateThe Multiple Device ObserverTwo HTML UI documentsThe sniffer clientThe Subject classesMultiple concrete observersThe mobile phone observerTablet observerDesktop viewThinking OOP