docs: add diagrams for decorator, delegation, dependency injection, dirty flag, domain model, double buffer, double-checked locking, double dispatch, and dynamic proxy

Author: iluwatar

decorator/README.md

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern as well as to the Open-Closed Principle, by allowing the functionality of a class to be extended without being modified.
 
+Sequence diagram
+
+![Decorator sequence diagram](./etc/decorator-sequence-diagram.png)
+
 ## Programmatic Example of Decorator Pattern in Java
 
 There is an angry troll living in the nearby hills. Usually, it goes bare-handed, but sometimes it has a weapon. To arm the troll it's not necessary to create a new troll but to decorate it dynamically with a suitable weapon.

decorator/etc/decorator-sequence-diagram.png

@@ -33,6 +33,10 @@ Wikipedia says
 
 > In object-oriented programming, delegation refers to evaluating a member (property or method) of one object (the receiver) in the context of another original object (the sender). Delegation can be done explicitly, by passing the sending object to the receiving object, which can be done in any object-oriented language; or implicitly, by the member lookup rules of the language, which requires language support for the feature.
 
+Sequence diagram
+
+![Delegation sequence diagram](./etc/delegation-sequence-diagram.png)
+
 ## Programmatic Example of Delegation Pattern in Java
 
 Let's consider a printing example.
@@ -114,10 +118,6 @@ Canon Printer:hello world
 Epson Printer:hello world
 ```
 
-## Detailed Explanation of Delegation Pattern with Real-World Examples
-
-![Delegate class diagram](./etc/delegation.png "Delegate")
-
 ## When to Use the Delegation Pattern in Java
 
 * When you want to pass responsibility from one class to another without inheritance.

delegation/README.md

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In software engineering, dependency injection is a technique in which an object receives other objects that it depends on. These other objects are called dependencies.
 
+Sequence diagram
+
+![Dependency Injection sequence diagram](./etc/dependency-injection-sequence-diagram.png)
+
 ## Programmatic Example of Dependency Injection Pattern in Java
 
 The old wizard likes to fill his pipe and smoke tobacco once in a while. However, he doesn't want to depend on a single tobacco brand only but likes to be able to enjoy them all interchangeably.

delegation/etc/delegation-sequence-diagram.png

@@ -34,6 +34,10 @@ Wikipedia says
 
 > A dirty bit or modified bit is a bit that is associated with a block of computer memory and indicates whether the corresponding block of memory has been modified. The dirty bit is set when the processor writes to (modifies) this memory. The bit indicates that its associated block of memory has been modified and has not been saved to storage yet. When a block of memory is to be replaced, its corresponding dirty bit is checked to see if the block needs to be written back to secondary memory before being replaced or if it can simply be removed. Dirty bits are used by the CPU cache and in the page replacement algorithms of an operating system.
 
+Flowchart
+
+![Dirty Flag flowchart](./etc/dirty-flag-flowchart.png)
+
 ## Programmatic Example of Dirty Flag Pattern in Java
 
 The `DataFetcher` class is responsible for fetching data from a file. It has a dirty flag that indicates whether the data in the file has changed since the last fetch.

dependency-injection/README.md

@@ -34,6 +34,10 @@ In plain words
 
 > The Domain Model is an object model of the domain that incorporates both behavior and data.
 
+Mind map
+
+![Domain Model mind map](./etc/domain-model-mind-map.png)
+
 ## Programmatic Example of Domain Model Pattern in Java
 
 Let's assume that we need to build an e-commerce web application. While analyzing requirements you will notice that there are few nouns you talk about repeatedly. It’s your Customer, and a Product the customer looks for. These two are your domain-specific classes and each of that classes will include some business logic specific to its domain.
@@ -225,10 +229,6 @@ The program output:
 12:17:23.846 [main] INFO com.iluwatar.domainmodel.Customer -- Tom bought: Eggs - $10.00, Cheese - $20.00
 ```
 
-## Detailed Explanation of Domain Model Pattern with Real-World Examples
-
-![Domain Model class diagram](./etc/domain-model.urm.png "Domain Model")
-
 ## When to Use the Domain Model Pattern in Java
 
 * Appropriate in complex applications with rich business logic.