舉報 
會員
Design Patterns and Best Practices in Java
Havingaknowledgeofdesignpatternsenablesyou,asadeveloper,toimproveyourcodebase,promotecodereuse,andmakethearchitecturemorerobust.Aslanguagesevolve,newfeaturestaketimetofullyunderstandbeforetheyareadoptedenmasse.Themissionofthisbookistoeasetheadoptionofthelatesttrendsandprovidegoodpracticesforprogrammers.WefocusonshowingyouthepracticalaspectsofsmartercodinginJava.We'llstartoffbygoingoverobject-oriented(OOP)andfunctionalprogramming(FP)paradigms,movingontodescribethemostfrequentlyuseddesignpatternsintheirclassicalformatandexplainhowJava’sfunctionalprogrammingfeaturesarechangingthem.YouwilllearntoenhanceimplementationsbymixingOOPandFP,andfinallygettoknowaboutthereactiveprogrammingmodel,whereFPandOOPareusedinconjunctionwithaviewtowritingbettercode.Gradually,thebookwillshowyouthelatesttrendsinarchitecture,movingfromMVCtomicroservicesandserverlessarchitecture.WewillfinishoffbyhighlightingthenewJavafeaturesandbestpractices.Bytheendofthebook,youwillbeabletoefficientlyaddresscommonproblemsfacedwhiledevelopingapplicationsandbecomfortableworkingonscalableandmaintainableprojectsofanysize.
目錄(314章)
倒序
- 封面
- 版權信息
- Packt Upsell
- Why subscribe?
- PacktPub.com
- Contributors
- About the authors
- About the reviewer
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- To get the most out of this book
- Download the example code files
- Download the color images
- Conventions used
- Get in touch
- Reviews
- From Object-Oriented to Functional Programming
- Java – an introduction
- Java programming paradigms
- Imperative programming
- Real-life imperative example
- Object-oriented paradigm
- Objects and classes
- Encapsulation
- Abstraction
- Inheritance
- Polymorphism
- Declarative programming
- Functional programming
- Working with collections versus working with streams
- An introduction to Unified Modeling Language
- Class relations
- Generalization
- Realization
- Dependency
- Association
- Aggregation
- Composition
- Design patterns and principles
- Single responsibility principle
- Open/closed principle
- Liskov Substitution Principle
- Interface Segregation Principle
- Dependency inversion principle
- Summary
- Creational Patterns
- Singleton pattern
- Synchronized singletons
- Synchronized singleton with double-checked locking mechanism
- Lock-free thread-safe singleton
- Early and lazy loading
- The factory pattern
- Simple factory pattern
- Static factory
- Simple factory with class registration using reflection
- Simple factory with class registration using Product.newInstance
- Factory method pattern
- Anonymous concrete factory
- Abstract factory
- Simple factory versus factory method versus abstract factory
- Builder pattern
- Car builder example
- Simplified builder pattern
- Anonymous builders with method chaining
- Prototype pattern
- Shallow clone versus deep clone
- Object pool pattern
- Summary
- Behavioral Patterns
- The chain-of-responsibility pattern
- Intent
- Implementation
- Applicability and examples
- The command pattern
- Intent
- Implementation
- Applicability and examples
- The interpreter pattern
- Intent
- Implementation
- Applicability and examples
- The iterator pattern
- Intent
- Implementation
- Applicability and examples
- The observer pattern
- Intent
- Implementation
- The mediator pattern
- Intent
- Implementation
- Applicability and examples
- The memento pattern
- Intent
- Implementation
- Applicability
- The state pattern
- The strategy pattern
- Intent
- Implementation
- The template method pattern
- Intent
- Implementation
- The null object pattern
- Implementation
- The visitor pattern
- Intent
- Implementation
- Summary
- Structural Patterns
- Adapter pattern
- Intent
- Implementation
- Examples
- Proxy pattern
- Intent
- Implementation
- Examples
- Decorator pattern
- Intent
- Implementation
- Examples
- Bridge pattern
- Intent
- Implementation
- Examples
- Composite pattern
- Intent
- Implementation
- Examples
- Fa?ade pattern
- Intent
- Implementation
- Examples
- Flyweight pattern
- Intent
- Implementation
- Examples
- Summary
- Functional Patterns
- Introducing functional programming
- Lambda expressions
- Pure functions
- Referential transparency
- First-class functions
- Higher-order functions
- Composition
- Currying
- Closure
- Immutability
- Functors
- Applicatives
- Monads
- Introducing functional programming in Java
- Lambda expressions
- Streams
- Stream creator operations
- Stream intermediate operations
- Stream terminal operations
- Re-implementing OOP design patterns
- Singleton
- Builder
- Adapter
- Decorator
- Chain of responsibility
- Command
- Interpreter
- Iterator
- Observer
- Strategy
- Template method
- Functional design patterns
- MapReduce
- Intent
- Examples
- Loan pattern
- Intent
- Examples
- Tail call optimization
- Intent
- Examples
- Memoization
- Intent
- Examples
- The execute around method
- Intent
- Examples
- Summary
- Let's Get Reactive
- What is reactive programming?
- Introduction to RxJava
- Installing the RxJava framework
- Maven installation
- JShell installation
- Observables Flowables Observers and Subscriptions
- Creating Observables
- The create operator
- The defer operator
- The empty operator
- The from operator
- The interval operator
- The timer operator
- The range operator
- The repeat operator
- Transforming Observables
- The subscribe operator
- The buffer operator
- The flatMap operator
- The groupBy operator
- The map operator
- The scan operator
- The window operator
- Filtering Observables
- The debounce operator
- The distinct operator
- The elementAt operator
- The filter operator
- The first/last operator
- The sample operator
- The skip operator
- The take operator
- Combining Observables
- The combine operator
- The join operator
- The merge operator
- The zip operator
- Error handling
- The catch operator
- The do operator
- The using operator
- The retry operator
- Schedulers
- Subjects
- Example project
- Summary
- Reactive Design Patterns
- Patterns for responsiveness
- Request-response pattern
- Asynchronous-communication pattern
- Caching pattern
- Fan-out and quickest-reply pattern
- Fail-fast pattern
- Patterns for resilience
- The circuit-breaker pattern
- Failure-handling pattern
- Bounded-queue pattern
- Monitoring patterns
- Bulkhead pattern
- Patterns for elasticity
- Single responsibility pattern
- Stateless-services pattern
- Autoscaling pattern
- Self-containment pattern
- Patterns for message-driven implementation
- Event-driven communication pattern
- Publisher-subscriber pattern
- Idempotency pattern
- Summary
- Trends in Application Architecture
- What is application architecture?
- Layered architecture
- Layered architecture with an example
- Tiers versus layers
- What does layered architecture guarantee?
- What are the challenges with layered architecture?
- Model View Controller architecture
- MVC architecture with an example
- A more contemporary MVC implementation
- What does MVC architecture guarantee?
- What are the challenges with MVC architecture?
- Service-oriented architecture
- Service-oriented architecture with an example
- Web services
- SOAP versus REST
- Enterprise service bus
- What does service-oriented architecture guarantee?
- What are the challenges with service-oriented architecture?
- Microservices-based Architecture
- Microservice architecture with an example
- Communicating among services
- What does microservices-based architecture guarantee?
- What are challenges with microservices-based architecture?
- Serverless architecture
- Serverless architecture with an example
- Independence from infrastructure planning
- What does serverless architecture guarantee?
- What are the challenges with serverless architecture?
- Summary
- Best Practices in Java
- A brief history of Java
- Features of Java 5
- Features of Java 8
- Currently supported versions of Java
- Best practices and new features of Java 9
- Java platform module system
- JShell
- Private methods in interfaces
- Enhancements in streams
- Creating immutable collections
- Method addition in arrays
- Additions to the Optional class
- New HTTP client
- Some more additions to Java 9
- Best practices and new features of Java 10
- Local variable type inference
- copyOf method for collections
- Parallelization of full garbage collection
- Some more additions to Java 10
- What should be expected in Java 11?
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-06-25 20:53:16
推薦閱讀
- Qt 5 and OpenCV 4 Computer Vision Projects
- C語言程序設計實踐教程（第2版）
- 微服務與事件驅動架構
- Apache Mesos Essentials
- Android Native Development Kit Cookbook
- Mastering Akka
- SciPy Recipes
- 創意UI：Photoshop玩轉APP設計
- Django Design Patterns and Best Practices
- Photoshop智能手機APP界面設計
- 從零開始學UI：概念解析、實戰提高、突破規則
- 微信公眾平臺開發最佳實踐
- Java Web應用開發
- 循序漸進Vue.js 3前端開發實戰
- 自己動手做智能產品：嵌入式JavaScript實現
- C++游戲設計案例教程
- 區塊鏈社會：區塊鏈助力國家治理能力現代化
- Mastering Predictive Analytics with R（Second Edition）
- Python自動化測試教程
- Go語言高級編程
- HTML5技術與移動出版
- Kivy：Interactive Applications and Games in Python（Second Edition）
- 公安計算機應用基礎
- INSTANT RaphaelJS Starter
- RESTful Java Patterns and Best Practices
- Learning BeagleBone Python Programming
- 算法小時代：從數學到生活的歷變
- Complete Virtual Reality and Augmented Reality Development with Unity
- C語言程序設計教程
- C# 5 First Look
