[디자인패턴] 브릿지 패턴(Bridge Pattern)

# 설명

• 기능의 확장과 구현의 확장을 따로 계층화 함
• 기능에 대한 여러가지 구현을 다양하게 적용 가능
• 기능과 구현을 혼재시키면 상속의 관계가 복잡해질 수 있기 떄문에 두 계층을 분리시켜 다리(Bridge)의 역할을 하게 함

기능의 확장과 구현의 확장을 따로 계층화 한다. 라는 말이 브릿지 패턴의 핵심이자 요지이다. 그러나 기능과 구현 또 이 확장이라는 것이 잘 와닿지 않을 수 있다. 이를 간단하게 설명해보자. 

## 구현 계층

 List라는 컬렉션은 LinkedList, ArrayList등 여러 형태로 구현이 가능하다. List라는 구현체에서 확장이라 함은 이러한 LinkedList,ArrayList와 같은 것이다. List를  vector로 구현의 확장이 가능할 것이다. 이렇게 리스트의 구현사항과 구현형태를 정의하도록 하는것이 Implementor계층이다. Implementor계층에서 이 List의 구현명세를 AbstrackList(Implementor)로 만들고 이 명세를 상속받아 ArrayImpl, LinkedListImpl(ConcreteImplementor)와 같이 List의 실 기능을 구현한다.

## 기능 계층

 Stack,Queue와 같은 기능은 List의 어떠한 방식(LinkedList,ArrayList,Vector...)을 사용하여 구현하여도 상관 없다. 그 기능의 역할만을 할 수 있으면 되기 때문이다. 이렇게 구현<->기능을 분리하여 기능이 구현의 방식에 얽매이지하지 않도록 한다.

 Abstraction은 Implementor(구현객체)의 참조자를 관리한다. Stack과 Queue의추상화 개념의 상위 클래스이다.

RefinedAbstraction은 추상화 개념의 확장된 기능을 정의한다 Stack과 Queue와 같이 말이다.

 

결국 기능과 구현을 분리시켜 독립적으로 변할 수 있게 하는 것이다.

 

# 코드

## 구현 계층

//AbstractList
public interface AbstractList<T> {
    public void addElement(T obj);
    public T deleteElement(int i);
    public int insertElement(T obj, int i);
    public T getElement(int i);
    public int getElementSize();
    public String toString();
}

// ArrayImpl
public class ArrayImpl<T> implements AbstractList<T>{

    ArrayList<T> array;

    public ArrayImpl(){
        array = new ArrayList<T>();
        System.out.println("ArrayList로 구현됨");
    }

    @Override
    public void addElement(T obj) {
        array.add(obj);
    }

    @Override
    public T deleteElement(int i) {
        return array.remove(i);
    }

    @Override
    public int insertElement(T obj, int i) {
        array.add(i,obj);
        return i;
    }

    @Override
    public T getElement(int i) {
        return array.get(i);
    }

    @Override
    public int getElementSize() {
        return array.size();
    }

    @Override
    public String toString() {
        return "ArrayList";
    }
}

// LinkedListImpl
public class LinkedListImpl<T> implements AbstractList<T>{

    LinkedList<T> linkedList;

    public LinkedListImpl(){
        linkedList = new LinkedList<T>();
        System.out.println("LinkedList로 구현 됨");
    }

    @Override
    public void addElement(T obj) {
        linkedList.add(obj);
    }

    @Override
    public T deleteElement(int i) {
        return linkedList.remove(i);
    }

    @Override
    public int insertElement(T obj, int i) {
        linkedList.add(i,obj);
        return i;
    }

    @Override
    public T getElement(int i) {
        return linkedList.get(i);
    }

    @Override
    public int getElementSize() {
        return linkedList.size();
    }

    @Override
    public String toString() {
        return "LinkedList";
    }
}

## 기능 계층

//List
public class List<T> {
    AbstractList<T> impl;

    public List(AbstractList<T> mImpl){
        impl = mImpl;
    }

    public void add(T obj){
        impl.addElement(obj);
    }

    public T get(int i){
        return impl.getElement(i);
    }

    public T remove(int i){
        return impl.deleteElement(i);
    }

    public int getSize(){
        return impl.getElementSize();
    }

}

//Queue
public class Queue<T> extends List<T>{
    public Queue(AbstractList<T> mImpl) {
        super(mImpl);
        System.out.println("Queue임");
    }

    public void enQueue(T obj){
        impl.addElement(obj);
    }

    public T deQueue(){
        return impl.deleteElement(0);
    }
}

//Stack
public class Stack<T> extends List<T> {
    public Stack(AbstractList<T> mImpl) {
        super(mImpl);
        System.out.println("Stack임");
    }

    public void push(T obj) {
        impl.insertElement(obj, 0);
    }

    public T pop() {
        return impl.deleteElement(0);
    }
}

#테스트

// Test
public class Test {
    public static void main(String[] args) {
        Queue<String> arrayQueue = new Queue<String>(new ArrayImpl<String>());

        arrayQueue.enQueue("aaa");
        arrayQueue.enQueue("bbb");
        arrayQueue.enQueue("ccc");

        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println("=========================");

        Queue<String> linkedQueue = new Queue<String>(new LinkedListImpl<String>());
        linkedQueue.enQueue("aaa");
        linkedQueue.enQueue("bbb");
        linkedQueue.enQueue("ccc");

        System.out.println(linkedQueue.deQueue());
        System.out.println(linkedQueue.deQueue());
        System.out.println(linkedQueue.deQueue());
        System.out.println("=========================");

        Stack<String> arrayStack = new Stack<String>(new ArrayImpl<String>());
        arrayStack.push("aaa");
        arrayStack.push("bbb");
        arrayStack.push("ccc");

        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
        System.out.println(arrayStack.pop());
        System.out.println("=========================");

        Stack<String> linkedStack = new Stack<String>(new LinkedListImpl<String>());
        linkedStack.push("aaa");
        linkedStack.push("bbb");
        linkedStack.push("ccc");

        System.out.println(linkedStack.pop());
        System.out.println(linkedStack.pop());
        System.out.println(linkedStack.pop());
        System.out.println("=========================");

    }