gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Resolves checkstyle errors for delegation dependency-injection dirty-flag double-buffer double-checked-locking double-dispatch (#1068)

Browse Source 
* Reduces checkstyle errors in delegation

* Reduces checkstyle errors in dependency-injection

* Reduces checkstyle errors in dirty-flag

* Reduces checkstyle errors in double-buffer

* Reduces checkstyle errors in double-checked-locking

* Reduces checkstyle errors in double-dispatch
This commit is contained in:
Anurag Agarwal
2019-11-10 23:01:20 +05:30
committed by Ilkka Seppälä
parent 01e489c77b
commit f2c91eb836
35 changed files with 154 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
double-dispatch/src/main/java/com/iluwatar/doubledispatch/App.java
View File

@ -23,46 +23,45 @@
package com.iluwatar.doubledispatch;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
/**
*
* When a message with a parameter is sent to an object, the resultant behaviour is defined by the implementation of
* that method in the receiver. Sometimes the behaviour must also be determined by the type of the parameter.
* <p>
* One way to implement this would be to create multiple instanceof-checks for the methods parameter. However, this
* creates a maintenance issue. When new types are added we would also need to change the method's implementation and
* add a new instanceof-check. This violates the single responsibility principle - a class should have only one reason
* to change.
* <p>
* Instead of the instanceof-checks a better way is to make another virtual call on the parameter object. This way new
* functionality can be easily added without the need to modify existing implementation (open-closed principle).
* <p>
* In this example we have hierarchy of objects ({@link GameObject}) that can collide to each other. Each object has its
* own coordinates which are checked against the other objects' coordinates. If there is an overlap, then the objects
* collide utilizing the Double Dispatch pattern.
* When a message with a parameter is sent to an object, the resultant behaviour is defined by the
* implementation of that method in the receiver. Sometimes the behaviour must also be determined by
* the type of the parameter.
*
* <p>One way to implement this would be to create multiple instanceof-checks for the methods
* parameter. However, this creates a maintenance issue. When new types are added we would also need
* to change the method's implementation and add a new instanceof-check. This violates the single
* responsibility principle - a class should have only one reason to change.
*
* <p>Instead of the instanceof-checks a better way is to make another virtual call on the
* parameter object. This way new functionality can be easily added without the need to modify
* existing implementation (open-closed principle).
*
* <p>In this example we have hierarchy of objects ({@link GameObject}) that can collide to each
* other. Each object has its own coordinates which are checked against the other objects'
* coordinates. If there is an overlap, then the objects collide utilizing the Double Dispatch
* pattern.
*/
public class App {
private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
/**
* Program entry point
*
* @param args
* command line args
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {
// initialize game objects and print their status
List<GameObject> objects = List.of(
new FlamingAsteroid(0, 0, 5, 5),
new SpaceStationMir(1, 1, 2, 2),
new Meteoroid(10, 10, 15, 15),
new SpaceStationIss(12, 12, 14, 14));
new FlamingAsteroid(0, 0, 5, 5),
new SpaceStationMir(1, 1, 2, 2),
new Meteoroid(10, 10, 15, 15),
new SpaceStationIss(12, 12, 14, 14));
objects.stream().forEach(o -> LOGGER.info(o.toString()));
LOGGER.info("");