모르니까 검색할거야

- 객체를 감싸서 실제와 다른 인터페이스를 가진 것처럼 보이도록 할 계획입니다.

이유?

: 특정 인터페이스를 필요로하는 디자인을 다른 인터페이스를 구현하는 클래스에 적응시킬 수 있기 때문입니다.

예제 구현

//오리 인터페이스
public interface Duck {
    void quack();
    void fly();
}

//그냥오리 인터페이스 구현
public class JustDuck implements Duck{
    @Override
    public void quack() {
        Log.d("abcd", "꽥꽥!!");
    }

    @Override
    public void fly() {
        Log.d("abcd","훨훨~");
    }
}

//새 인터페이스
public interface Bird {
    void gobble();
    void fly();
}


//그냥새 구현
public class JustBird implements Bird{
    @Override
    public void gobble() {
        Log.d("abcd","짹짹!!");
    }

    @Override
    public void fly() {
        Log.d("abcd","날아랏!");
    }
}

// 어뎁터 구현
// 새는 birdAdapter로 감싸서 오리처럼 보이게 만듭니다.
public class BirdAdapter implements Duck{
	//객체를 감쌀때는 구성을 사용
    Bird bird;

    public BirdAdapter(Bird bird) {
        this.bird = bird;
    }

    @Override
    public void quack() {
        //오리의 울음소리 메소드에 새의 울음소리를 입력합니다.
        bird.gobble();
    }

    @Override
    public void fly() {
        bird.fly();
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Bird bird = new JustBird();
        //duck을 adapter에 implements 하였기 때문에 가능
        Duck duck = new BirdAdapter(bird);


        // 메소드 출력
        duck.fly();
        duck.quack();
    }
}

D/abcd: 날아랏!
        짹짹!!

.

.

전체적인 어댑터패턴 구현 순서

1. 클라이언트에서 타켓(오리) 인터페이스를 사용하여 메소드를 호출함으로써 어댑터에 요청합니다.

2. 어댑터에서는 어댑티(새) 인터페이스를 사용하여 그 요청을 어댑티(새)에 대한  메소드 호출로 변환합니다.

3. 클라이언트에서는 호출 결과를 받긴하지만 중간에 어댑터가 껴 있는지는 전혀 알지 못합니다.

.

.

어댑터 패턴 : 한 클래스의 인터페이스를 클라이언트에서 사용하고자 하는 다른 인터페이스로 변환합니다.
어댑터를 이용하면, 인터페이스 호환성 문제 때문에 같이 쓸 수 없는 클래스들을 연결해서 쓸 수 있습니다.

.

.

코틀린

// 오리
interface Duck {
    fun quack()
    fun fly()
}

// 그냥 오리
class JustDuck : Duck {
    override fun quack() {
        Log.d("abcd","꽥꽥!")
    }

    override fun fly() {
        Log.d("abcd","훨훨~")
    }
}

//새
interface Bird {
    fun gobble()
    fun fly()
}


//그냥 새
class JustBird : Bird {
    override fun gobble() {
        Log.d("abcd","짹짹")
    }

    override fun fly() {
        Log.d("abcd","훨훨!")
    }
}

//어댑터
class Adapter constructor(bird: Bird) : Duck {

    var bird:Bird? = null

    init {
        this.bird = bird
    }

    override fun quack() {
        bird?.gobble()
    }

    override fun fly() {
       bird?.fly()
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        val bird = JustBird()
        var adapter:Duck = Adapter(bird)


        adapter.fly()
        adapter.quack()

    }
}


D/abcd: 훨훨!
짹짹