book

Practical Design Patterns for Java Developers

by Miroslav Wengner

February 2023

Intermediate to advanced

266 pages

5h 53m

English

Packt Publishing

Read now

Unlock full access

ForewordContributorsAbout the authorAbout the reviewer
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Technical requirementsCode – from symbols to programExamining OOP and APIEOnly exposing what’s required – encapsulationInevitable evolution – inheritanceBehavior on demand – polymorphismStandard features – abstractionGluing parts to APIEUnderstanding the SOLID design principlesThe single-responsibility principle (SRP) – the engine is just an engineThe open-closed principle (OCP)The Liskov Substitution Principle (LSP) – substitutability of classesThe interface segregation principle (ISP)The dependency inversion principle (DIP)Significance of design patternsReviewing what challenges design patterns solveSummaryQuestionsFurther reading
Technical requirementsKnocking on Java’s doorExploring the model and functionality of the Java platformThe JDKThe JREThe JVMReviewing GC and the Java memory modelThe JMMGC and automatic memory managementExamining the core Java APIsPrimitive data types and wrappersWorking with the String APIIntroducing arraysDiscovering a collection frameworkMath APIsFunctional programming and JavaIntroducing lambdas and functional interfacesUsing functional interfaces in lambda expressionsGetting to grips with the Java Module SystemA quick review of Java features from 11 to 17+The local variable syntax for lambda parameters (Java SE 11, JEP-323)Switch expressions (Java SE 14, JEP-361)Text blocks (Java SE 15, JEP-378)Pattern matching for instanceof (Java SE 16, JEP-394)Records (Java SE 16, JEP-395)Sealed classes (Java SE 17, JEP-409)UTF-8 by default (Java SE 18, JEP-400)Pattern matching for switch (Java SE 18, Second Preview, JEP-420)Understanding Java concurrencyFrom a basic thread to executorsExecuting tasksSummaryQuestionsFurther reading
Technical requirementsIt all starts with a class that becomes an objectCreating objects based on input with the factory method patternMotivationFinding it in the JDKSample codeConclusionCreating objects from different families using the abstract factory patternMotivationFinding it in the JDKSample codeConclusionInstantiating complex objects with the builder patternMotivationFinding it in the JDKSample codeConclusionCloning objects with the prototype patternMotivationFinding it in the JDKSample codeConclusionEnsuring only one instance with the singleton patternMotivationFinding it in the JDKSample codeConclusionImproving performance with the object pool patternMotivationFinding it in the JDKSample codeConclusionInitiating objects on demand with the lazy initialization patternMotivationFinding it in the JDKSample codeConclusionReducing class dependencies with the dependency injection patternMotivationFinding it in the JDKSample codeConclusionSummaryQuestionsFurther reading
Technical requirementsIncompatible object collaboration with the adapter patternMotivationFinding it in the JDKSample codeConclusionDecoupling and developing objects independently with the bridge patternMotivationFinding it in the JDKSample codeConclusionTreating objects the same way using the composite patternMotivationFinding it in the JDKSample codeConclusionExtending object functionality by using the decorator patternMotivationFinding it in the JDKSample codeConclusionSimplifying communication with the facade patternMotivationFinding it in the JDKSample codeConclusionUsing conditions to select desired objects with the filter patternMotivationFinding it in the JDKSample codeConclusionSharing objects across an application with the flyweight patternMotivationFinding it in the JDKSample codeConclusionHandling requests with the front-controller patternMotivationFinding it in the JDKSample codeConclusionIdentifying instances using the marker patternMotivationFinding it in the JDKSample codeConclusionExploring the concept of modules with the module patternMotivationFinding it in the JDKSample codeConclusionProviding a placeholder for an object using the proxy patternMotivationFinding it in the JDKSample codeConclusionDiscovering multiple inheritance in Java with the twin patternMotivationSample codeConclusionSummaryQuestionsFurther reading
Technical requirementsLimiting expensive initialization using the caching patternMotivationFinding it in the JDKSample codeConclusionHandling events using the chain of responsibility patternMotivationFinding it in the JDKSample codeConclusionTurning information into action with the command patternMotivationFinding it in the JDKSample codeConclusionGiving meaning to the context using the interpreter patternMotivationFinding it in the JDKSample codeConclusionChecking all the elements with the iterator patternMotivationFinding it in the JDKSample codeConclusionUtilizing the mediator pattern for information exchangeMotivationFinding it in the JDKSample codeConclusionRestoring the desired state with the memento patternMotivationFinding it in the JDKSample codeConclusionAvoiding a null pointer exception state with the null object patternMotivationFinding it in the JDKSample codeConclusionKeeping all interested parties informed using the observer patternMotivationFinding it in the JDKSample codeConclusionDealing with instance stages by using the pipeline patternMotivationFinding it in the JDKSample codeConclusionChanging object behavior with the state patternMotivationFinding it in the JDKSample codeConclusionUsing the strategy pattern to change object behaviorMotivationFinding it in the JDKSample codeConclusionStandardizing processes with the template patternMotivationFinding it in the JDKSample codeConclusionExecuting code based on the object type using the visitor patternMotivationFinding it in the JDKSample codeConclusionSummaryQuestionsFurther reading

Technical requirementsDecoupling a method execution with an active object patternMotivationSample codeConclusionNon-blocking tasks using async method invocation patternMotivationSample codeConclusionDelay execution until the previous task is completed with the balking patternMotivationSample codeConclusionProviding a unique object instance with a double-checked locking patternMotivationSample codeConclusionUsing purposeful thread blocking via a read-write lock patternMotivationSample codeConclusionDecoupling the execution logic with a producer-consumer patternMotivationSample codeConclusionExecuting isolated tasks with the scheduler patternMotivationSample codeConclusionEffective thread utilization using a thread-pool patternMotivationSample codeConclusionSummaryQuestionsFurther readingAnswers
Technical requirementsWhat anti-patterns are and how to identify themTheoretical principles challengesCollecting technical debt as a bottleneckInappropriately squeezing the capabilities of the Java platformSelecting the right toolConclusion of the code smell anti-patternExamining typical software anti-patternsSpaghetti codeCut and paste programmingBlobLava flowFunctional decompositionBoat anchorConclusionUnderstanding software architecture anti-patternsGolden hammerContinuous obsolescenceInput kludgeWorking in a minefieldAmbiguous viewpointPoltergeistsDead endConclusionSummaryFurther reading
Chapter 1 – Getting into Software Design PatternsChapter 2 – Discovering the Java Platform for Design PatternsChapter 3 – Working with Creational Design PatternsChapter 4 – Applying Structural Design PatternsChapter 5 – Behavioral Design PatternsChapter 6 – Concurrency Design Patterns
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Practical Design Patterns for Java Developers

3 Working with Creational Design Patterns

In recent decades, the IT community has experienced a dramatic shift from previously isolated systems to distributed or hybrid solutions. These approaches bring to light new possibilities for software development.

Distribution solutions may appear to meet the migration needs of legacy systems, but the reality may prove otherwise. The required refactoring can cause additional problems due to the division of responsibilities or refactoring of tightly coupled logic and business rules and many unknown, hidden logics that are discovered too late to react to.

In this chapter, we will explore creational design patterns. These patterns play a vital role in the software composition. They are very useful for achieving ...