The Java Design Patterns Course

Identify your Windows architecture to install the proper JDK: 64-bit requires Java SE 11, 32-bit uses Java SE 8, then download and install.

download and install IntelliJ IDEA (community edition) on Windows, then configure JDK 11 and set editor preferences like auto import and line numbers for a ready Java development environment.

Install the JDK 11 on Mac, download the Oracle JDK 11 LTS, and install it using the macOS dmg wizard to prepare for writing and running Java programs in IntelliJ.

Install and configure IntelliJ IDEA on Mac, choose the Community Edition, link it to the Java Development Kit, and adjust basic preferences for beginner-friendly Java programming.

Download and install java development kit 11 on Ubuntu Linux by downloading the java se 11 lts JDK tar.gz, extracting it to /usr/lib/jvm, and configuring java and javac with update-alternatives.

Install and configure IntelliJ IDEA on Linux, select the community edition, connect the JDK, set language level to 11, and enable auto import and line numbers.

Understand design principles and patterns that emphasize abstraction, encapsulation, high cohesion, low coupling, single responsibility, open/closed, and dependency injection for maintainable, extensible software.

Explore design smells in Java design, including rigidity, fragility, immobility, viscosity, needless repetition, opacity, and needless complexity; learn how design patterns promote high cohesion and loose coupling for maintainable code.

Program to an interface declares variables by a supertype and uses polymorphism to swap implementations at runtime, as shown by a monitor and projector example with loose coupling.

Explore composition over inheritance to build loosely coupled, encapsulated Java designs. Learn how has-a relationships power patterns like strategy and decorator, improve testability, and enable flexible software reuse.

Learn how delegation lets one class forward responsibilities to a delegate via object composition, increasing cohesion and runtime flexibility, with design pattern examples like state, strategy, visitor, and event delegation.

Learn the single responsibility principle by distinguishing cohesive classes with low coupling, and refactor an overburdened employee class into dedicated HR promotions and finance classes for focused responsibilities.

Discover how the open for extension, closed for modification principle guides extending functionality via interfaces rather than inheritance, enabling new shapes to be added without altering existing code.

Demonstrate the Liskov substitution principle by showing that subclass objects replace superclass objects without breaking behavior, using polymorphism and consistent input and return values.

Learn how the interface segregation principle splits fat interfaces into lean, cohesive ones so clients implement only used methods.

Explore the dependency inversion principle, where high- and low-level classes depend on abstractions, not concrete implementations, to achieve loose coupling via interfaces.

Learn how dependency injection replaces hard dependencies in client and service relationships with loose coupling by injecting services via constructors, setters, or interfaces, aligning with the dependency inversion principle.

Learn how UML, the unified modeling language, documents and visualizes design through diagrams such as class diagrams and sequence diagrams, a communication tool for object-oriented analysis, design, and design patterns.

Explore class diagrams, the main UML structural diagram, for modeling the static design of object-oriented systems, illustrating classes, attributes, methods, and relationships such as has-a and is-a.

Learn to draw class diagrams with UML notation, representing classes as rectangles with name, attributes, and methods, and applying inheritance, aggregation, composition, and dependency relationships using standard symbols.

Explore UML class diagrams and how the abstract factory, adapter, singleton, decorator, and strategy patterns are represented with symbols, relationships, and cardinality.

Explore creational design patterns, including factory, abstract factory, singleton, builder, and prototype, and learn how dependency injection and programming to interfaces enable open for extensibility and closed for modification.

Explore the factory method design pattern, a creational approach that decouples object creation from use by coding to an interface and deferring instantiation.

Learn the strictest factory method implementation with an abstract creator, concrete creators, and shape products (circle, square, rectangle), and how clients instantiate specific products via the factory method.

Learn a single concrete creator class factory method approach that uses a shape factory with a get shape method accepting a string to create circle, rectangle, or square, reducing subclasses.

Learn static factory methods in the Java design patterns course by using a static get shape method to create circle, rectangle, and square without instantiating a factory.

Apply the factory method pattern to create duck and tiger objects with a single factory method that returns an animal reference, then invoke walk or eat to verify correct instantiation.

Implement a factory method to create duck and tiger objects from an animal interface, and demonstrate via a client that calls speak and handles an invalid type with an exception.

Explore the abstract factory pattern, a creational design pattern that creates families of related products. It uses composition and the factory method to decouple clients from concrete classes.

Implement the abstract factory method pattern by selecting a family of products, such as shapes or colors, using a factory producer and concrete factories.

Apply the abstract factory method pattern to create Hollywood or Bollywood movies by genre, using interfaces and concrete classes to produce action or comedy movie instances.

Demonstrate the abstract factory method by modeling Hollywood and Bollywood movie products with action and comedy factory families. Show how a factory producer selects the right factory and movie.

Master the singleton design pattern, a creational pattern that guarantees a single instance with a global access point and private constructor, useful for printers, file systems, and logging.

Compare singleton and dependency injection in Java design patterns. Learn when DI replaces singletons, reduces statics, and improves unit testing with constructor or setter injection.

Master the singleton design pattern with a private constructor and a public static getInstance, and explore five approaches: lazy, synchronized, double-checked locking, eager, and bill pugh inner static class.

Explore the lazy initialization singleton pattern by implementing a private constructor and a get instance method, then test singleton behavior while detailing thread-safety risks and potential race conditions.

Demonstrates a thread-safe singleton using a synchronized getInstance method, preserves lazy initialization while explaining bottlenecks, race conditions, and overhead, and sets the stage for double-check locking.

Master the double-checked locking pattern to implement a singleton with a volatile instance, synchronizing only inside the first check to achieve thread-safe lazy initialization and better performance.

Explain eager initialization of singletons, created at class load time with a thread-safe static initializer, its drawbacks, and introduce the Bill Pugh lazy singleton via an inner static helper class.

Explore the Bill Pugh singleton pattern with an inner static helper class that lazily creates the instance without synchronization, ensuring thread safety.

Explore the Bill Pugh singleton approach by modeling a cricket captain as a single instance, then verify the same instance via getInstance and equals with a simple main method.

Shows the bill pugh singleton in Java, with a private constructor, a static inner helper class, and a get captain method to guarantee a single instance, plus a main tester.

Explore the builder design pattern, which separates complex object construction from representation, enabling multi-step, flexible creation of varying representations like vacation planners or string builders.

Explore how the builder pattern uses a director, a builder, and a concrete builder to assemble a product from parts. Highlight features include abstraction, modularity, and controlled construction.

Implement the builder pattern by designing a builder interface, concrete builders for car and motorcycle, and a director to assemble the vehicle product in an IntelliJ project.

Explore the builder design pattern through creating meals using veggie and chicken burgers with coke or Pepsi, wrapped or bottled, via a director, concrete builders, and a meal product.

demonstrates the builder design pattern by constructing vegetarian and non-vegetarian meals from burgers and drinks, using a director, meal builders, and packing with wrappers and bottles.

Master the prototype design pattern to copy a prototypical object, reducing costly object creation. Learn shallow vs deep copies, Java cloning issues, and when to use deserialization for deep copies.

Implement the prototype design pattern by cloning objects via a prototype interface and concrete prototypes. Use a shape cache to store prototypes and supply clones through the client.

Explore the issues of the clonable interface in Java, including shallow versus deep copies, and compare alternatives like copy constructors and serialization for the prototype design pattern.

Explore the prototype design pattern in Java by implementing a basic car prototype with nano and ford clones, using a basic car cache to return duplicates.

Demonstrates the prototype design pattern by building a clonable basic car hierarchy with Ford and nano, using a cache to retrieve clones and adjust their prices.