舉報 
會員
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
推薦閱讀
- Mastering Concurrency Programming with Java 8
- Clojure Programming Cookbook
- JavaScript+jQuery網頁特效設計任務驅動教程（第2版）
- Java Web基礎與實例教程
- Spring Boot企業級項目開發實戰
- 飛槳PaddlePaddle深度學習實戰
- Mathematica Data Analysis
- C語言程序設計
- Java程序設計入門
- HTML5+CSS3 Web前端開發技術（第2版）
- Learning Concurrency in Kotlin
- Mastering Backbone.js
- 零基礎學HTML+CSS第2版
- Learning Bootstrap 4（Second Edition）
- Scratch編程從入門到精通
- 量子計算機編程：從入門到實踐
- Raspberry Pi Robotic Projects
- ASP.NET Core 2 High Performance（Second Edition）
- Programming MapReduce with Scalding
- Visual Basic實例精通
- 高效C/C++調試
- JavaScript和jQuery實戰手冊（原書第3版）
- 構建企業級推薦系統：算法、工程實現與案例分析
- Tkinter GUI Application Development Cookbook
- Beginning C# 7 Hands-On：Advanced Language Features
- OpenStack Administration with Ansible
- JavaScript前端開發案例教程
- Visual Basic程序設計教程（第3版）
- XMind：用好思維導圖走上開掛人生
- Instant Kendo UI Grid
