디자인 모드 의 어댑터 모드 (2): 오래된 버 전 인터페이스 와 제3자 인터페이스

머리말
참고: http://c.biancheng.net/view/1...

현실 생활 에서 두 대상 이 인터페이스 가 호 환 되 지 않 아 함께 일 하지 못 하 는 사례 가 자주 나타 나 는데 이때 제3자 가 적당 한 조합 을 해 야 한다.예 를 들 어 중국 어 를 말 하 는 사람 이 영 어 를 말 하 는 사람과 대화 할 때 통역 이 필요 하고, 직류 전 기 를 사용 하 는 노트북 으로 전원 을 연결 할 때 전원 어댑터 가 필요 하 며, 컴퓨터 로 카메라 의 SD 메모리 카드 에 접근 할 때 카드 리더 가 필요 하 다 는 등 이다.

소프트웨어 디자인 에서 도 나타 날 수 있다. 특정한 업무 기능 을 가 진 구성 요 소 는 기 존의 구성 요소 라 이브 러 리 에 이미 존재 하지만 현재 시스템 의 인터페이스 규범 과 호 환 되 지 않 는 다. 만약 에 이런 구성 요 소 를 재 개발 하 는 비용 이 매우 높 으 면 어댑터 모델 로 이런 문 제 를 잘 해결 할 수 있다.

내용.
1. 패턴 정의 와 특징
어댑터 모드 (Adapter) 의 정 의 는 다음 과 같다. 하나의 인 터 페 이 스 를 고객 이 원 하 는 다른 인터페이스 로 바 꾸 어 인터페이스 가 호 환 되 지 않 아 함께 일 할 수 없 었 던 클래스 들 이 함께 일 할 수 있 도록 한다.어댑터 모델 은 클래스 구조 형 모델 과 대상 구조 형 모델 두 가지 로 나 뉘 는데 전자 클래스 간 의 결합 도가 후자 보다 높 고 프로그래머 에 게 기 존 구성 요소 라 이브 러 리 의 관련 구성 요소 의 내부 구 조 를 이해 하도록 요구 하기 때문에 응용 이 상대 적 으로 적다.
이 모델 의 주요 장점 은 다음 과 같다.

클 라 이언 트 는 어댑터 를 통 해 목표 인 터 페 이 스 를 투명 하 게 호출 할 수 있다.

기 존의 종 류 를 재 활용 했다. 프로그래머 는 기 존의 코드 를 수정 하지 않 고 기 존의 어댑터 종 류 를 재 활용 했다.

목표 류 와 어댑터 류 를 결합 시 켜 목표 류 와 어댑터 류 인터페이스 가 일치 하지 않 는 문 제 를 해결 했다.

클래스 어댑터 의 경우 어댑터 교체 의 실현 과정 이 복잡 하 다 는 단점 이 있다.
2. 패턴 의 구조
클래스 어댑터 모드 는 다 중 계승 방식 으로 이 루어 집 니 다. 예 를 들 어 C + + 는 현재 시스템 의 업무 인터페이스 와 기 존 구성 요소 라 이브 러 리 에 존재 하 는 구성 요소 인 터 페 이 스 를 동시에 계승 할 수 있 습 니 다.자바 는 다 중 계승 은 지원 되 지 않 지만 어댑터 클래스 를 정의 하여 현재 시스템 의 업무 인 터 페 이 스 를 실현 하 는 동시에 기 존 구성 요소 라 이브 러 리 에 존재 하 는 구성 요 소 를 계승 할 수 있 습 니 다.
패턴 의 구조:
어댑터 모드 (Adapter) 는 다음 과 같은 주요 역할 을 포함 합 니 다.

목표 (Target) 인터페이스: 현재 시스템 업무 가 기대 하 는 인터페이스 로 추상 류 나 인터페이스 일 수 있 습 니 다.

어댑터 (Adaptee) 클래스: 기 존 구성 요소 라 이브 러 리 에 접근 되 고 적합 한 구성 요소 인터페이스 입 니 다.

어댑터 (Adapter) 클래스: 어댑터 입 니 다. 어댑터 의 대상 을 계승 하거나 인용 하여 어댑터 인 터 페 이 스 를 목표 인터페이스 로 전환 하여 고객 이 목표 인터페이스의 형식 에 따라 어댑터 에 접근 하도록 합 니 다.

3. 패턴 의 인 스 턴 스
3.1 장면 소개
장면 소개: (1) 우리 가 1 판 시스템 을 만 들 었 다 고 가정 하면 이 시스템 에 하나의 인터페이스 와 하나의 실현 류 (2) 가 있 고 이어서 우 리 는 2 판 시스템 을 시작 했다. 이 시스템 은 우 리 는 새로운 인터페이스 와 새로운 실현 류 (3) 를 정 의 했 지만 우 리 는 2 판 시스템 에서1 판 시스템 에서 정 의 된 오래된 인터페이스 와 오래된 실현 류 도 사용 해 야 한다.
3.2 디자인 모델 없 이 실현

public class NonPatternApplication {
    public static void main(String[] args) {
        OldInterface oldInterface = new OldInterfaceImpl();
        NewInterface newInterface = new NewInterfaceImpl();

        oldInterface.oldRun();
        newInterface.newRun();

        /**
         *            ，       ?
         *        ,   ,       ，                  ，            
         *   ，   ，                  
         *                     ，           ，      ？
         *                   ？
         */
    }


    //===============  ====================
    //      
    public static interface OldInterface{
        void oldRun();
    }

    //     
    public static interface NewInterface{
        void newRun();
    }
    //================   ====================
    public static class OldInterfaceImpl implements OldInterface{
        public void oldRun() {
            System.out.println("       ");
        }
    }

    public static class NewInterfaceImpl implements NewInterface{
        public void newRun() {
            System.out.println("       ");
        }
    }

}

3.3 어댑터 모드 구현

public class AdapterPatternApplication {

    public static void main(String[] args) {
        NewInterface oldInterface = new NewInterfaceAdapter(new OldInterfaceImpl());
        NewInterface newInterface = new NewInterfaceImpl();

        //            ，                 
        oldInterface.newRun();
        newInterface.newRun();

        //      
        //                      
        //                 ，              ，            
        //                  
        //     "       "，        "           "
        //             ，    "          "     
        //        ，            ，            ，          
    }

    //===============   ===================

     public static class NewInterfaceAdapter implements NewInterface{
         private OldInterface oldInterface;

         public NewInterfaceAdapter(OldInterface oldInterface){
             this.oldInterface = oldInterface;
         }
         public void newRun() {
            oldInterface.oldRun();
         }
     }

    //===============  ====================
    //      
    public static interface OldInterface{
        void oldRun();
    }

    //     
    public static interface NewInterface{
        void newRun();
    }
    //================   ====================
    public static class OldInterfaceImpl implements OldInterface {
        public void oldRun() {
            System.out.println("       ");
        }
    }

    public static class NewInterfaceImpl implements NewInterface {
        public void newRun() {
            System.out.println("       ");
        }
    }
}