- Summary 更新時間：2021-07-08 09:42:58
- Conclusion
- Using the data access layer
- Bridge layer
- Data helper layer
- Data model layer
- The design
- Requirements
- Data access layer
- Conclusion
- The design
- Requirements
- Logging service
- Case Studies
- Summary
- Implementing the observer pattern
- Understanding the solution
- Understanding the problem
- The observer pattern
- Implementing the strategy pattern
- Understanding the solution
- Understanding the problem
- The strategy pattern
- Implementing the command pattern
- Understanding the solution
- Understanding the problem
- The command design pattern
- Behavioral design patterns
- Implementing the proxy pattern
- Understanding the solution
- Understanding the problem
- The proxy design pattern
- Implementing the facade pattern
- Understanding the solution
- Understanding the problem
- The facade pattern
- Implementing the bridge pattern
- Understanding the solution
- Understanding the problem
- The bridge pattern
- Structural design patterns
- Implementing the factory method pattern
- Understanding the solution
- Understanding the problem
- The factory method pattern
- Implementing the builder pattern
- Understanding the solution
- Understanding the problem
- The builder design pattern
- Implementing the singleton pattern
- Understanding the solution
- Understanding the problem
- The singleton design pattern
- Creational patterns
- What are design patterns?
- Adopting Design Patterns in Swift
- Summary
- The winner is...
- Using value and reference types
- Implementing vehicle types
- Protocol and protocol extensions compared with superclasses
- Differences between object-oriented programming and protocol-oriented programming
- Summarizing protocol-oriented programming and object-oriented programming
- Swift as a protocol-oriented programming language
- Requirements for the sample code
- Protocol-Oriented Programming
- Summary
- Issues with the object-oriented design
- Swift as an object-oriented programming language
- Requirements for the sample code
- What is object-oriented programming?
- Object-Oriented Programming
- Summary
- Generics in the Swift standard library
- Generics in a protocol-oriented design
- Copy-on-write
- Generic subscripts
- Associated types
- Generic types
- Type constraints with Generics
- Generic functions
- Generics
- Summary
- Conforming to the Equatable protocol
- Extensions with the Swift standard library
- Text validation
- Protocol extensions
- Defining an extension
- Extensions
- Summary
- Copy-on-write
- Swift's built-in types
- Dynamic dispatch
- Inheritance for reference types only
- Recursive data types for reference types only
- Value and reference types
- Protocols
- Tuples
- Enumerations
- Access controls
- Structures
- Classes
- Our Type Choices
- Summary
- Protocols in the Swift standard library
- Designing with protocols
- Delegation
- Associated types with protocols
- Type casting with protocols
- Polymorphism with protocols
- Using protocols as a type
- Protocol composition
- Protocol inheritance
- Optional requirements
- Method requirements
- Property requirements
- Defining a protocol
- Protocol syntax
- Starting with the Protocol
- Questions
- Piracy
- Errata
- Downloading the color images of this book
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewer
- About the Author
- Credits
- Third Edition
- Swift 4 Protocol-Oriented Programming
- Copyright
- Third Edition
- Title Page
- coverpage
- coverpage
- Title Page
- Third Edition
- Copyright
- Swift 4 Protocol-Oriented Programming
- Third Edition
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions
- Starting with the Protocol
- Protocol syntax
- Defining a protocol
- Property requirements
- Method requirements
- Optional requirements
- Protocol inheritance
- Protocol composition
- Using protocols as a type
- Polymorphism with protocols
- Type casting with protocols
- Associated types with protocols
- Delegation
- Designing with protocols
- Protocols in the Swift standard library
- Summary
- Our Type Choices
- Classes
- Structures
- Access controls
- Enumerations
- Tuples
- Protocols
- Value and reference types
- Recursive data types for reference types only
- Inheritance for reference types only
- Dynamic dispatch
- Swift's built-in types
- Copy-on-write
- Summary
- Extensions
- Defining an extension
- Protocol extensions
- Text validation
- Extensions with the Swift standard library
- Conforming to the Equatable protocol
- Summary
- Generics
- Generic functions
- Type constraints with Generics
- Generic types
- Associated types
- Generic subscripts
- Copy-on-write
- Generics in a protocol-oriented design
- Generics in the Swift standard library
- Summary
- Object-Oriented Programming
- What is object-oriented programming?
- Requirements for the sample code
- Swift as an object-oriented programming language
- Issues with the object-oriented design
- Summary
- Protocol-Oriented Programming
- Requirements for the sample code
- Swift as a protocol-oriented programming language
- Summarizing protocol-oriented programming and object-oriented programming
- Differences between object-oriented programming and protocol-oriented programming
- Protocol and protocol extensions compared with superclasses
- Implementing vehicle types
- Using value and reference types
- The winner is...
- Summary
- Adopting Design Patterns in Swift
- What are design patterns?
- Creational patterns
- The singleton design pattern
- Understanding the problem
- Understanding the solution
- Implementing the singleton pattern
- The builder design pattern
- Understanding the problem
- Understanding the solution
- Implementing the builder pattern
- The factory method pattern
- Understanding the problem
- Understanding the solution
- Implementing the factory method pattern
- Structural design patterns
- The bridge pattern
- Understanding the problem
- Understanding the solution
- Implementing the bridge pattern
- The facade pattern
- Understanding the problem
- Understanding the solution
- Implementing the facade pattern
- The proxy design pattern
- Understanding the problem
- Understanding the solution
- Implementing the proxy pattern
- Behavioral design patterns
- The command design pattern
- Understanding the problem
- Understanding the solution
- Implementing the command pattern
- The strategy pattern
- Understanding the problem
- Understanding the solution
- Implementing the strategy pattern
- The observer pattern
- Understanding the problem
- Understanding the solution
- Implementing the observer pattern
- Summary
- Case Studies
- Logging service
- Requirements
- The design
- Conclusion
- Data access layer
- Requirements
- The design
- Data model layer
- Data helper layer
- Bridge layer
- Using the data access layer
- Conclusion
- Summary 更新時間：2021-07-08 09:42:58
