Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Title Page
Copyright and Credits
Design Patterns and Best Practices in Java
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
← Prev
Back
Next →
← Prev
Back
Next →