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

Fixed code to follow coding conventions

Browse Source
This commit is contained in:
JuhoKang
2015-12-07 10:35:32 +09:00
parent 33b41f872e
commit e2d8079b36
5 changed files with 66 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
adapter/src/main/java/com/iluwatar/adapter/App.java
View File

@ -1,43 +1,38 @@
package com.iluwatar.adapter;
/**
* An adapter helps two incompatible interfaces to work together. This is the
* real world definition for an adapter. Interfaces may be incompatible but the
* inner functionality should suit the need. The Adapter design pattern allows
* otherwise incompatible classes to work together by converting the interface
* of one class into an interface expected by the clients.
*
* An adapter helps two incompatible interfaces to work together. This is the real world definition
* for an adapter. Interfaces may be incompatible but the inner functionality should suit the need.
* The Adapter design pattern allows otherwise incompatible classes to work together by converting
* the interface of one class into an interface expected by the clients.
*
* <p>
* There are two variations of the Adapter pattern: The class adapter implements
* the adaptee's interface whereas the object adapter uses composition to
* contain the adaptee in the adapter object. This example uses the object
* adapter approach.
*
* There are two variations of the Adapter pattern: The class adapter implements the adaptee's
* interface whereas the object adapter uses composition to contain the adaptee in the adapter
* object. This example uses the object adapter approach.
*
* <p>
* The Adapter ({@link BattleFishingBoat}) converts the interface of the adaptee
* class ( {@link FishingBoat}) into a suitable one expected by the client (
* {@link BattleShip} ).
*
* The Adapter ({@link BattleFishingBoat}) converts the interface of the adaptee class (
* {@link FishingBoat}) into a suitable one expected by the client ( {@link BattleShip} ).
*
* <p>
* The story of this implementation is this. <br>
* Pirates are coming! we need a {@link BattleShip} to fight! We have a
* {@link FishingBoat} and our captain. We have no time to make up a new ship!
* we need to reuse this {@link FishingBoat}. The captain needs a battleship
* which can fire and move. The spec is in {@link BattleShip}. We will use the
* Adapter pattern to reuse {@link FishingBoat}.
*
* Pirates are coming! we need a {@link BattleShip} to fight! We have a {@link FishingBoat} and our
* captain. We have no time to make up a new ship! we need to reuse this {@link FishingBoat}. The
* captain needs a battleship which can fire and move. The spec is in {@link BattleShip}. We will
* use the Adapter pattern to reuse {@link FishingBoat}.
*
*/
public class App {
/**
* Program entry point.
*
* @param args
* command line args
*/
public static void main(String[] args) {
Captain captain = new Captain(new BattleFishingBoat());
captain.move();
captain.fire();
}
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {
Captain captain = new Captain(new BattleFishingBoat());
captain.move();
captain.fire();
}
}

4
adapter/src/main/java/com/iluwatar/adapter/BattleFishingBoat.java
View File

@ -1,13 +1,13 @@
package com.iluwatar.adapter;
/**
*
*
* Adapter class. Adapts the interface of the device ({@link FishingBoat}) into {@link BattleShip}
* interface expected by the client ({@link Captain}). <br>
* In this case we added a new function fire to suit the interface. We are reusing the
* {@link FishingBoat} without changing itself. The Adapter class can just map the functions of the
* Adaptee or add, delete features of the Adaptee.
*
*
*/
public class BattleFishingBoat implements BattleShip {

2
adapter/src/main/java/com/iluwatar/adapter/BattleShip.java
View File

@ -3,7 +3,7 @@ package com.iluwatar.adapter;
/**
* The interface expected by the client.<br>
* A Battleship can fire and move.
*
*
*/
public interface BattleShip {

4
adapter/src/main/java/com/iluwatar/adapter/FishingBoat.java
View File

@ -1,9 +1,9 @@
package com.iluwatar.adapter;
/**
*
*
* Device class (adaptee in the pattern). We want to reuse this class
*
*
*/
public class FishingBoat {

93
adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java
View File

@ -15,77 +15,52 @@ import com.iluwatar.adapter.Captain;
import com.iluwatar.adapter.FishingBoat;
/**
* An adapter helps two incompatible interfaces to work together. This is the
* real world definition for an adapter. Interfaces may be incompatible but the
* inner functionality should suit the need. The Adapter design pattern allows
* otherwise incompatible classes to work together by converting the interface
* of one class into an interface expected by the clients.
*
* <p>
* There are two variations of the Adapter pattern: The class adapter implements
* the adaptee's interface whereas the object adapter uses composition to
* contain the adaptee in the adapter object. This example uses the object
* adapter approach.
*
* <p>
* The Adapter ({@link BattleFishingBoat}) converts the interface of the adaptee
* class ( {@link FishingBoat}) into a suitable one expected by the client (
* {@link BattleShip} ).
*
* <p>
* The story of this implementation is this. <br>
* Pirates are coming! we need a {@link BattleShip} to fight! We have a
* {@link FishingBoat} and our captain. We have no time to make up a new ship!
* we need to reuse this {@link FishingBoat}. The captain needs a battleship
* which can fire and move. The spec is in {@link BattleShip}. We will use the
* Adapter pattern to reuse {@link FishingBoat} which operates properly
* Test class
*
*/
public class AdapterPatternTest {
private Map<String, Object> beans;
private Map<String, Object> beans;
private static final String BATTLESHIP_BEAN = "engineer";
private static final String BATTLESHIP_BEAN = "engineer";
private static final String CAPTAIN_BEAN = "captain";
private static final String CAPTAIN_BEAN = "captain";
/**
* This method runs before the test execution and sets the bean objects in
* the beans Map.
*/
@Before
public void setup() {
beans = new HashMap<>();
/**
* This method runs before the test execution and sets the bean objects in the beans Map.
*/
@Before
public void setup() {
beans = new HashMap<>();
BattleFishingBoat battleFishingBoat = spy(new BattleFishingBoat());
beans.put(BATTLESHIP_BEAN, battleFishingBoat);
BattleFishingBoat battleFishingBoat = spy(new BattleFishingBoat());
beans.put(BATTLESHIP_BEAN, battleFishingBoat);
Captain captain = new Captain();
captain.setBattleship((BattleFishingBoat) beans.get(BATTLESHIP_BEAN));
beans.put(CAPTAIN_BEAN, captain);
}
Captain captain = new Captain();
captain.setBattleship((BattleFishingBoat) beans.get(BATTLESHIP_BEAN));
beans.put(CAPTAIN_BEAN, captain);
}
/**
* This test asserts that when we use the move() method on a captain
* bean(client), it is internally calling move method on the battleship
* object. The Adapter ({@link BattleFishingBoat}) converts the interface of
* the target class ( {@link FishingBoat}) into a suitable one expected by
* the client ({@link Captain} ).
*/
@Test
public void testAdapter() {
BattleShip captain = (BattleShip) beans.get(CAPTAIN_BEAN);
/**
* This test asserts that when we use the move() method on a captain bean(client), it is
* internally calling move method on the battleship object. The Adapter ({@link BattleFishingBoat}
* ) converts the interface of the target class ( {@link FishingBoat}) into a suitable one
* expected by the client ({@link Captain} ).
*/
@Test
public void testAdapter() {
BattleShip captain = (BattleShip) beans.get(CAPTAIN_BEAN);
// when captain moves
captain.move();
// when captain moves
captain.move();
// the captain internally calls the battleship object to move
BattleShip battleship = (BattleShip) beans.get(BATTLESHIP_BEAN);
verify(battleship).move();
// the captain internally calls the battleship object to move
BattleShip battleship = (BattleShip) beans.get(BATTLESHIP_BEAN);
verify(battleship).move();
// same with above with firing
captain.fire();
verify(battleship).fire();
// same with above with firing
captain.fire();
verify(battleship).fire();
}
}
}