Adapter Ontwerppatroon in Java

Adapter ontwerppatroon is een van de structurele ontwerppatronen en wordt gebruikt zodat twee niet-gerelateerde interfaces samen kunnen werken. Het object dat deze niet-gerelateerde interface verbindt, wordt een Adapter genoemd.

Adapter Ontwerppatroon

Een geweldig real-life voorbeeld van het Adapter ontwerppatroon is een mobiele oplader. De mobiele batterij heeft 3 volt nodig om op te laden, maar het normale stopcontact levert ofwel 120V (VS) of 240V (India). Dus de mobiele oplader fungeert als een adapter tussen de oplaadpoort van de mobiel en het stopcontact. We zullen proberen een multi-adapter te implementeren met behulp van het Adapter ontwerppatroon in deze tutorial. Dus allereerst zullen we twee klassen hebben – Volt (om volts te meten) en Socket (die constante volts van 120V produceert).

package com.journaldev.design.adapter;

public class Volt {

	private int volts;
	
	public Volt(int v){
		this.volts=v;
	}

	public int getVolts() {
		return volts;
	}

	public void setVolts(int volts) {
		this.volts = volts;
	}
	
}

package com.journaldev.design.adapter;

public class Socket {

	public Volt getVolt(){
		return new Volt(120);
	}
}

Nu willen we een adapter bouwen die 3 volt, 12 volt en standaard 120 volt kan produceren. Dus allereerst zullen we een adapterinterface maken met deze methoden.

package com.journaldev.design.adapter;

public interface SocketAdapter {

	public Volt get120Volt();
		
	public Volt get12Volt();
	
	public Volt get3Volt();
}

Tweeweg Adapterpatroon

Tijdens het implementeren van het Adapterpatroon zijn er twee benaderingen – de klasse-adapter en de objectadapter – echter produceren beide benaderingen hetzelfde resultaat.

1. Klasse Adapter – Deze vorm maakt gebruik van java overerving en breidt de broninterface uit, in ons geval de Socket-klasse.
2. Object Adapter – Deze vorm maakt gebruik van Java Compositie en de adapter bevat het bronobject.

Adapter Ontwerppatroon – Klasse Adapter

Hier is de implementatie van de klasse-adapter benadering van onze adapter.

package com.journaldev.design.adapter;

//Gebruik van overerving voor adapterpatroon
public class SocketClassAdapterImpl extends Socket implements SocketAdapter{

	@Override
	public Volt get120Volt() {
		return getVolt();
	}

	@Override
	public Volt get12Volt() {
		Volt v= getVolt();
		return convertVolt(v,10);
	}

	@Override
	public Volt get3Volt() {
		Volt v= getVolt();
		return convertVolt(v,40);
	}
	
	private Volt convertVolt(Volt v, int i) {
		return new Volt(v.getVolts()/i);
	}

}

Adapter Ontwerppatroon – Implementatie Object Adapter

Hier is de implementatie van de Object adapter van onze adapter.

package com.journaldev.design.adapter;

public class SocketObjectAdapterImpl implements SocketAdapter{

	//Gebruik van compositie voor adapterpatroon
	private Socket sock = new Socket();
	
	@Override
	public Volt get120Volt() {
		return sock.getVolt();
	}

	@Override
	public Volt get12Volt() {
		Volt v= sock.getVolt();
		return convertVolt(v,10);
	}

	@Override
	public Volt get3Volt() {
		Volt v= sock.getVolt();
		return convertVolt(v,40);
	}
	
	private Volt convertVolt(Volt v, int i) {
		return new Volt(v.getVolts()/i);
	}
}

Merk op dat beide adapter-implementaties bijna hetzelfde zijn en ze implementeren de SocketAdapter-interface. De adapter-interface kan ook een abstracte klasse zijn. Hier is een testprogramma om onze adapter-ontwerppatroonimplementatie te gebruiken.

package com.journaldev.design.test;

import com.journaldev.design.adapter.SocketAdapter;
import com.journaldev.design.adapter.SocketClassAdapterImpl;
import com.journaldev.design.adapter.SocketObjectAdapterImpl;
import com.journaldev.design.adapter.Volt;

public class AdapterPatternTest {

	public static void main(String[] args) {
		
		testClassAdapter();
		testObjectAdapter();
	}

	private static void testObjectAdapter() {
		SocketAdapter sockAdapter = new SocketObjectAdapterImpl();
		Volt v3 = getVolt(sockAdapter,3);
		Volt v12 = getVolt(sockAdapter,12);
		Volt v120 = getVolt(sockAdapter,120);
		System.out.println("v3 volts using Object Adapter="+v3.getVolts());
		System.out.println("v12 volts using Object Adapter="+v12.getVolts());
		System.out.println("v120 volts using Object Adapter="+v120.getVolts());
	}

	private static void testClassAdapter() {
		SocketAdapter sockAdapter = new SocketClassAdapterImpl();
		Volt v3 = getVolt(sockAdapter,3);
		Volt v12 = getVolt(sockAdapter,12);
		Volt v120 = getVolt(sockAdapter,120);
		System.out.println("v3 volts using Class Adapter="+v3.getVolts());
		System.out.println("v12 volts using Class Adapter="+v12.getVolts());
		System.out.println("v120 volts using Class Adapter="+v120.getVolts());
	}
	
	private static Volt getVolt(SocketAdapter sockAdapter, int i) {
		switch (i){
		case 3: return sockAdapter.get3Volt();
		case 12: return sockAdapter.get12Volt();
		case 120: return sockAdapter.get120Volt();
		default: return sockAdapter.get120Volt();
		}
	}
}

Wanneer we het bovenstaande testprogramma uitvoeren, krijgen we de volgende uitvoer.

v3 volts using Class Adapter=3
v12 volts using Class Adapter=12
v120 volts using Class Adapter=120
v3 volts using Object Adapter=3
v12 volts using Object Adapter=12
v120 volts using Object Adapter=120

Klassen Diagram van het Adapter-ontwerppatroon

Voorbeeld van het Adapter-ontwerppatroon in JDK

Sommige voorbeelden van het adapter-ontwerppatroon die ik gemakkelijk kon vinden in JDK-klassen zijn:

• java.util.Arrays#asList()
• java.io.InputStreamReader(InputStream) (retourneert een Reader)
• java.io.OutputStreamWriter(OutputStream) (retourneert een Writer)

Dat is alles voor het adapter-ontwerppatroon in Java.