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

issue #292

Browse Source
This commit is contained in:
JuhoKang
2015-12-01 16:00:31 +09:00
parent 5bec63659f
commit 119d264779
10 changed files with 139 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,28 +1,43 @@
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.
* <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}.
*
* <p>The Adapter ({@link GnomeEngineer}) converts the interface of the target class (
* {@link GoblinGlider}) into a suitable one expected by the client ({@link GnomeEngineeringManager}
* ).
*/
public class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {
Engineer manager = new GnomeEngineeringManager(new GnomeEngineer());
manager.operateDevice();
}
/**
* Program entry point.
*
* @param args
* command line args
*/
public static void main(String[] args) {
Captain captain = new Captain(new BattleFishingBoat());
captain.move();
captain.fire();
}
}

11
adapter/src/main/java/com/iluwatar/adapter/Engineer.java
View File

@@ -1,11 +0,0 @@
package com.iluwatar.adapter;
/**
*
* Engineers can operate devices.
*
*/
public interface Engineer {
void operateDevice();
}

23
adapter/src/main/java/com/iluwatar/adapter/GnomeEngineer.java
View File

@@ -1,23 +0,0 @@
package com.iluwatar.adapter;
/**
*
* Adapter class. Adapts the interface of the device ({@link GoblinGlider}) into {@link Engineer}
* interface expected by the client ({@link GnomeEngineeringManager}).
*
*/
public class GnomeEngineer implements Engineer {
private GoblinGlider glider;
public GnomeEngineer() {
glider = new GoblinGlider();
}
@Override
public void operateDevice() {
glider.attachGlider();
glider.gainSpeed();
glider.takeOff();
}
}

26
adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java
View File

@@ -1,26 +0,0 @@
package com.iluwatar.adapter;
/**
* GnomeEngineering manager uses {@link Engineer} to operate devices.
*/
public class GnomeEngineeringManager implements Engineer {
private Engineer engineer;
public GnomeEngineeringManager() {
}
public GnomeEngineeringManager(Engineer engineer) {
this.engineer = engineer;
}
@Override
public void operateDevice() {
engineer.operateDevice();
}
public void setEngineer(Engineer engineer) {
this.engineer = engineer;
}
}

21
adapter/src/main/java/com/iluwatar/adapter/GoblinGlider.java
View File

@@ -1,21 +0,0 @@
package com.iluwatar.adapter;
/**
*
* Device class (adaptee in the pattern).
*
*/
public class GoblinGlider {
public void attachGlider() {
System.out.println("Glider attached.");
}
public void gainSpeed() {
System.out.println("Gaining speed.");
}
public void takeOff() {
System.out.println("Lift-off!");
}
}

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

@@ -9,60 +9,83 @@ import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import com.iluwatar.adapter.BattleFishingBoat;
import com.iluwatar.adapter.BattleShip;
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.
* 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>
* 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
*
* <p>The Adapter ({@link GnomeEngineer}) converts the interface
* of the target class ({@link GoblinGlider}) into a suitable one expected by
* the client ({@link GnomeEngineeringManager}
* ).
*/
public class AdapterPatternTest {
private Map<String, Object> beans;
private Map<String, Object> beans;
private static final String ENGINEER_BEAN = "engineer";
private static final String BATTLESHIP_BEAN = "engineer";
private static final String MANAGER_BEAN = "manager";
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<>();
GnomeEngineer gnomeEngineer = spy(new GnomeEngineer());
beans.put(ENGINEER_BEAN, gnomeEngineer);
BattleFishingBoat battleFishingBoat = spy(new BattleFishingBoat());
beans.put(BATTLESHIP_BEAN, battleFishingBoat);
GnomeEngineeringManager manager = new GnomeEngineeringManager();
manager.setEngineer((GnomeEngineer) beans.get(ENGINEER_BEAN));
beans.put(MANAGER_BEAN, manager);
}
Captain captain = new Captain();
captain.setBattleship((BattleFishingBoat) beans.get(BATTLESHIP_BEAN));
beans.put(CAPTAIN_BEAN, captain);
}
/**
* This test asserts that when we call operateDevice() method on a manager bean, it is internally
* calling operateDevice method on the engineer object. The Adapter ({@link GnomeEngineer})
* converts the interface of the target class ( {@link GoblinGlider}) into a suitable one expected
* by the client ({@link GnomeEngineeringManager} ).
*/
@Test
public void testAdapter() {
Engineer manager = (Engineer) beans.get(MANAGER_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 manager is asked to operate device
manager.operateDevice();
// when captain moves
captain.move();
// Manager internally calls the engineer object to operateDevice
Engineer engineer = (Engineer) beans.get(ENGINEER_BEAN);
verify(engineer).operateDevice();
}
// 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();
}
}