Analyse von Java-Entwurfsmustern: So implementieren Sie das Adaptermuster

1. Was ist der Adaptermodus:

Der Adaptermodus wird hauptsächlich verwendet Um eine zu konvertieren, wird die Schnittstelle der Klasse in das vom Client gewünschte Zielklassenformat konvertiert, sodass ursprünglich inkompatible Klassen zusammenarbeiten und gleichzeitig die Zielklasse und die Adapterklasse entkoppelt werden können -close-Prinzip“ und kann ohne Änderung des Originalcodes verwendet werden. Fügen Sie neue Adapterklassen auf der Grundlage von hinzu. Es ist komplizierter.

Daher eignet sich der Adaptermodus besser für die folgenden Szenarien:

• (1) Das System muss vorhandene Klassen verwenden und die Schnittstellen dieser Klassen entsprechen nicht der Schnittstelle des Systems.

• (2) Wenn Sie Komponenten von Drittanbietern verwenden, unterscheidet sich die Definition der Komponentenschnittstelle von Ihrer eigenen Definition. Sie möchten Ihre eigene Schnittstelle nicht ändern, müssen es aber tun Nutzen Sie die Funktionen der Drittanbieter-Komponentenschnittstelle.

Die folgenden zwei sehr anschaulichen Beispiele veranschaulichen gut, was das Adaptermuster ist:

# 🎜🎜#

2. Drei Möglichkeiten zur Implementierung des Adaptermusters:

Das Adaptermuster ist hauptsächlich in drei Kategorien unterteilt: Klassenadaptermuster, Objektadaptermuster, Adaptermodus für die Schnittstelle.

1. Klassenadaptermuster:

#🎜🎜 #

Zielschnittstelle (Target): Die Schnittstelle, die Kunden erwarten. Das Ziel kann eine konkrete oder abstrakte Klasse oder eine Schnittstelle sein.
Klasse, die angepasst werden muss (Adaptee): Eine Klasse, die angepasst werden muss, oder eine Adapterklasse.
Adapter: Konvertiert die ursprüngliche Schnittstelle in die Zielschnittstelle, indem ein Objekt verpackt wird, das angepasst werden muss.

// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
	public void specificRequest() {
		System.out.println("被适配类具有 特殊功能...");
	}
}
 
// 目标接口，或称为标准接口
interface Target {
	public void request();
}
 
// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
	public void request() {
		System.out.println("普通类 具有 普通功能...");
	}
}
 
// 适配器类，继承了被适配类，同时实现标准接口
class Adapter extends Adaptee implements Target{
	public void request() {
		super.specificRequest();
	}
}
 
// 测试类public class Client {
	public static void main(String[] args) {
		// 使用普通功能类
		Target concreteTarget = new ConcreteTarget();
		concreteTarget.request();
		
		// 使用特殊功能类，即适配类
		Target adapter = new Adapter();
		adapter.request();
	}
}

Laufergebnis:

普通类 具有 普通功能...
被适配类具有 特殊功能...

2. Objektadaptermodus:

#🎜 🎜 #

// 适配器类，直接关联被适配类，同时实现标准接口
class Adapter implements Target{
	// 直接关联被适配类
	private Adaptee adaptee;
	
	// 可以通过构造函数传入具体需要适配的被适配类对象
	public Adapter (Adaptee adaptee) {
		this.adaptee = adaptee;
	}
	
	public void request() {
		// 这里是使用委托的方式完成特殊功能
		this.adaptee.specificRequest();
	}
}
 
// 测试类
public class Client {
	public static void main(String[] args) {
		// 使用普通功能类
		Target concreteTarget = new ConcreteTarget();
		concreteTarget.request();
		
		// 使用特殊功能类，即适配类，
		// 需要先创建一个被适配类的对象作为参数
		Target adapter = new Adapter(new Adaptee());
		adapter.request();
	}
}

Die Testergebnisse stimmen mit den oben genannten überein. Aus dem Klassendiagramm wissen wir auch, dass lediglich die interne Struktur der Adapter-Klasse geändert werden muss. Das heißt, der Adapter selbst muss zunächst über ein Objekt der angepassten Klasse verfügen und dann bestimmte Sonderfunktionen an dieses Objekt delegieren Durchführung. Mithilfe des Objektadaptermodus kann die Adapterklasse (Anpassungsklasse) basierend auf dem eingehenden Adaptee-Objekt an mehrere verschiedene angepasste Klassen angepasst werden. Natürlich können wir zu diesem Zeitpunkt eine Schnittstelle für mehrere angepasste Klassen oder abstrakte Klassen extrahieren. Es scheint, dass der Objektadaptermodus flexibler ist.

3. Adaptermuster der Schnittstelle:

Manchmal gibt es mehrere abstrakte Methoden in einer Schnittstelle, die wir schreiben, wenn wir sie implementieren Als Klasse müssen Sie alle Methoden der Schnittstelle implementieren. Dies ist manchmal offensichtlich verschwenderisch, da nicht alle Methoden das sind, was wir brauchen, sondern manchmal nur bestimmte. Um dieses Problem zu lösen, stellen wir hier das Adaptermuster der Schnittstelle vor Mit Hilfe einer abstrakten Klasse implementiert die abstrakte Klasse die Schnittstelle und alle Methoden. Wir beschäftigen uns jedoch nicht mit der ursprünglichen Schnittstelle, sondern nehmen nur Kontakt mit der abstrakten Klasse auf, also schreiben wir eine Klasse und erben die abstrakte Klasse , und neu. Schreiben Sie einfach die Methode, die wir brauchen. Schauen Sie sich das Klassendiagramm an:

In der tatsächlichen Entwicklung stoßen wir häufig auf zu viele Methoden, die in dieser Schnittstelle definiert sind. so dass wir es manchmal in einigen Implementierungsklassen nicht alle brauchen. Schauen Sie sich den Code an:

public interface Sourceable {
	
	public void method1();
	public void method2();
}

Abstract class Wrapper2:

public abstract class Wrapper2 implements Sourceable{
	
	public void method1(){}
	public void method2(){}
}

public class SourceSub1 extends Wrapper2 {
	public void method1(){
		System.out.println("the sourceable interface's first Sub1!");
	}
}

public class SourceSub2 extends Wrapper2 {
	public void method1(){
		System.out.println("the sourceable interface's second Sub2!");
	}
}

public class WrapperTest {
 
	public static void main(String[] args) {
		Sourceable source1 = new SourceSub1();
		Sourceable source2 = new SourceSub2();
		
		source1.method1();
		source1.method2();
		source2.method1();
		source2.method2();
	}
}

Laufendes Ergebnis:

the sourceable interface's first Sub1!
the sourceable interface's second Sub2!

Das obige ist der detaillierte Inhalt vonAnalyse von Java-Entwurfsmustern: So implementieren Sie das Adaptermuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!