06.アダプタモード

実施方法

// Target
interface Target {
  void operation();
}

// Adaptee
public class Adaptee {
  
  public void specificOperation() {
    // do something...
  }
  
}

// Object Adapter
public class ObjectAdapter implements Target {

  private final Adaptee adaptee;

  public ObjectAdapter(Adaptee adaptee) {
    this.adaptee = adaptee;
  }

  @Override
  public void operation() {
    adaptee.specificOperation();
  }
  
}

// Class Adapter
public class ClassAdapter extends Adaptee implements Target {

  @Override
  public void operation() {
    super.specificOperation();
  }

}

public static void main(String[] args) {
  Target targetObjectAdapter = new ObjectAdapter(new Adaptee());
  Target targetClassAdapter = new ClassAdapter();

  targetObjectAdapter.operation();
  targetClassAdapter.operation();
}

メリットとデメリット

長所

短所

07.ブリッジモード

実施方法

// Abstraction
public class Shape {

  private final Color color;
  private final String name;

  public Shape(Color color, String name) {
    this.color = color;
    this.name = name;
  }

  public void printInfo() {
    System.out.printf("%s %s\n", color.getValue(), this.name);
  }
  
}

// Refined Abstraction 1
public class Triangle extends Shape {

  public Triangle(Color color) {
    super(color, "triangle");
  }

  // 기능 추가...
  
}

// Refined Abstraction 1
public class Pentagon extends Shape {

  public Triangle(Color color) {
    super(color, "pentagon");
  }

  // 기능 추가...

}

// Implementation
public interface Color {
  String getValue();
}

// Concrete Implementation 1
public class Green implements Color {
  public void getValue(){
    return "green";
  }
}

// Concrete Implementation 2
public class Red implements Color {
  public void getValue(){
    return "red";
  }
}

public static void main(String[] args) {
  Shape triangle = new Triangle(new Red());
  triangle.printInfo();

  Shape pentagon = new Pentagon(new Green());
  pentagon.printInfo();
}

メリットとデメリット

長所

短所

08.複合モード

実施方法

// Component
public interface Validator {
  void validate(String input);
}

// Leaf 1
public class EmptyValidator implements Validator {
  
  @Override
  public void validate(String input) {
    if (isEmpty(input)) {
      throw new IllegalArgumentException("input must not be empty");
    }
  }

  private boolean isEmpty(String input) {
    return input == null || input.isEmpty();
  }
}

// Leaf 2
public class InputPatternValidator implements Validator {
  
  private static final Pattern PATTERN = Pattern.compile("^\\d+ [-+*/] \\d+$");

  @Override
  public void validate(String input) {
    if (!PATTERN.matcher(input).matches()) {
      throw new IllegalArgumentException("invalid input pattern");
    }
  }
}

// Composite
public class CompositeValidator implements Validator {

  private final List<Validator> validators;

  public CompositeValidator(Validator... validators) {
    this.validators = Arrays.asList(validators);
  }

  @Override
  public void validate(String input) {
    validators.forEach(validator -> validator.validate(input));
  }
}

public static void main(String[] args) {
  Validator validator =  new CompositeValidator(new EmptyValidator(), new InputPatternValidator());
  validator.validate("10 + 25");
}

メリットとデメリット

長所

短所

09.装飾図案

実施方法

// Component
interface ChristmasTree {
  String decorate();
}

// ConcreteComponent
public class DefaultChristmasTree implements ChristmasTree {
  
  @Override
  public String decorate() {
    return "Christmas tree";
  }
  
}

// Decorator
public class TreeDecorator implements ChristmasTree {
  
  private final ChristmasTree christmasTree;

  public TreeDecorator(ChristmasTree christmasTree) {
    this.christmasTree = christmasTree;
  }

  @Override
  public String decorate() {
    return christmasTree.decorate();
  }
  
}

// Concrete Decorator 1
public class LightsTreeDecorator extends TreeDecorator {

  public LightsTreeDecorator(ChristmasTree christmasTree) {
    super(christmasTree);
  }
  
  @Override
  public String decorate() {
    return super.decorate() + addLights();
  }

  private String addLights() {
    return " with Lights";
  }
  
}

// Concrete Decorator 2
public class FlowersTreeDecorator extends TreeDecorator {

  public FlowersTreeDecorator(ChristmasTree christmasTree) {
    super(christmasTree);
  }

  @Override
  public String decorate() {
    return super.decorate() + addFlowers();
  }

  private String addFlowers() {
    return " with Flowers";
  }
  
}

public static void main(String[] args) {
  ChristmasTree tree = new FlowersTreeDecorator(new LightsTreeDecorator(new DefaultChristmasTree()));

  // Christmas tree with Lights with Flowers 
  System.out.println("tree: " + tree.decorate()); 
}

メリットとデメリット

長所

短所

に役立つ

10.グループ化モード

実施方法

// Facade
public class GoOffice {

  public void goToWork() {
    Wash wash = new Wash();
    Breakfast breakfast = new Breakfast();
    Move move = new Move();

    wash.brushTeeth();
    wash.shower();
    breakfast.eat();
    breakfast.water();
    move.bus();
  }
  
}

// Sub System 1
public class Wash {
  
  public void brushTeeth() {
    System.out.println("Brush my teeth");
  }

  public void shower() {
    System.out.println("Take a shower");
  }
  
}

// Sub System 2
public class Breakfast {
  
  public void eat() {
    System.out.println("Have breakfast");
  }

  public void water() {
    System.out.println("Drink water");
  }
  
}

// Sub System 3
public class Move {
  
  public void bus() {
    System.out.println("Take the bus");
  }
  
}

public static void main(String[] args) {
  GoOffice goOffice = new GoOffice();
  goOffice.goToWork();
}

メリットとデメリット

長所

短所

に役立つ

11.フローティングモード

実施方法

// Flyweight
public final class Font {

  private final String family;
  private final int size;

  public Font(String family, int size) {
    this.family = family;
    this.size = size;
  }

  public String getFamily() {
    return family;
  }

  public int getSize() {
    return size;
  }
  
}

// Flyweight Factory
public class FontFactory {

  private static final Map<String, Font> CACHE = new HashMap<>();

  public static Font getFont(String font) {
    Font result = CACHE.get(font);
    if (result == null) {
      String[] split = font.split(":");
      result = new Font(split[0], Integer.parseInt(split[1]));
      cache.put(font, result);
    }
    
    return result;
  }
  
}

public static void main(String[] args) {
    Font font1 = FontFactory.getFont("Arial:12");
    Font font2 = FontFactory.getFont("Arial:12");

    assert font1 == font2;
}

メリットとデメリット

長所

短所

に役立つ

12.エージェント・モード

実施方法

// Subject
public interface OrderService {
  void order();
}

// RealSubject
public class DefaultOrderService implements OrderService {

  @Override
  public void order() {
    System.out.println("주문하기...");
  }
  
}

// Proxy
public class OrderServiceProxy implements OrderService {

  private OrderService orderService;

  @Override
  public void startGame() {
    long before = System.currentTimeMillis();
    
    if (this.orderService == null) {
      this.orderService = new DefaultOrderService();
    }

    orderService.order();

    System.out.println(System.currentTimeMillis() - before);
  }
  
}

public static void main(String[] args) {
  OrderService orderService = new OrderServiceProxy();
  orderService.order();
}

メリットとデメリット

長所

短所

に役立つ

Decoratorモードとエージェントモード