Java-Entwurfsmuster-Analyse-Adaptermuster (detailliertes Beispiel)

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, in dem hauptsächlich Probleme im Zusammenhang mit Entwurfsmustern vorgestellt werden und hauptsächlich auf das Adaptermuster eingegangen wird, das hauptsächlich zum Konvertieren der Schnittstelle einer Klasse in das vom Client gewünschte Ziel verwendet wird Das Klassenformat ermöglicht die Zusammenarbeit ursprünglich inkompatibler Klassen und entkoppelt Zielklassen und Adapterklassen. Ich hoffe, dass es für alle hilfreich ist.

Empfohlenes Lernen: „Java-Video-Tutorial“

1. Was ist das Adaptermuster:

Das Adaptermuster wird hauptsächlich verwendet, um die Schnittstelle einer Klasse in das vom Client gewünschte Zielklassenformat zu konvertieren , so dass ursprünglich nicht kompatible Klassen zusammenarbeiten können, um die Zielklasse und die Adapterklasse gleichzeitig zu entkoppeln. Außerdem entspricht es dem „Öffnungs- und Schließprinzip“ und neue Adapterklassen können hinzugefügt werden, ohne den ursprünglichen Code zu ändern ; Die spezifische Implementierung ist in der Adapterklasse gekapselt, was für die Client-Klasse transparent ist und die Wiederverwendbarkeit des Adapters verbessert. Der Nachteil besteht jedoch darin, dass der Implementierungsprozess zum Ersetzen des Adapters relativ kompliziert ist. Daher eignet sich das Adaptermuster besser für die folgenden Szenarien:

(1) Das System muss vorhandene Klassen verwenden und die Schnittstellen dieser Klassen stimmen nicht mit den Schnittstellen des Systems überein.

(2) Bei Verwendung von Komponenten von Drittanbietern unterscheidet sich die Definition der Komponentenschnittstelle von Ihrer eigenen Definition. Sie möchten Ihre eigene Schnittstelle nicht ändern, sondern müssen die Funktionen der Komponentenschnittstelle von Drittanbietern verwenden.
• Die folgenden zwei sehr anschaulichen Beispiele veranschaulichen gut, was das Adaptermuster ist:

2. Drei Implementierungsmethoden des Adaptermusters:

Das Adaptermuster ist hauptsächlich in drei Kategorien unterteilt: Klassenadaptermuster , Adaptermuster für Objekte, Adaptermuster für Schnittstellen.

1. Klassenadaptermuster:

Zielschnittstelle (Ziel): die Schnittstelle, die Kunden erwarten. Das Ziel kann eine konkrete oder abstrakte Klasse oder eine Schnittstelle sein.

Klasse, die angepasst werden muss (Adaptee): Die Klasse, die angepasst werden muss, oder die Adapterklasse.
• Adapter: Konvertieren Sie die ursprüngliche Schnittstelle in die Zielschnittstelle, indem Sie ein Objekt packen, 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();
  	}
  }

Laufende Ergebnisse:

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

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, d. h. der Adapter selbst muss zunächst ein Objekt der angepassten Klasse haben 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 die Implementierungsklasse der Schnittstelle schreiben, müssen wir alle Methoden der Schnittstelle implementieren, was manchmal offensichtlich verschwenderisch ist Da nicht alle Methoden das sind, was wir brauchen, werden manchmal nur bestimmte benötigt. Um dieses Problem zu lösen, führen wir das Adaptermuster der Schnittstelle mit Hilfe einer abstrakten Klasse ein, die die Schnittstelle implementiert und alle Methoden implementiert. Und wir beschäftigen uns nicht mit der ursprünglichen Schnittstelle, sondern nehmen nur Kontakt mit der abstrakten Klasse auf, also schreiben wir eine Klasse, erben die abstrakte Klasse und schreiben die von uns benötigten Methoden neu. Schauen Sie sich das Klassendiagramm an:

Das ist leicht zu verstehen. In der tatsächlichen Entwicklung stoßen wir häufig auf zu viele Methoden, die in dieser Schnittstelle definiert sind, sodass wir in einigen Implementierungsklassen manchmal nicht alle benötigen. 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();
	}
}

Laufergebnisse:

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

Empfohlenes Lernen: „

Java-Video-Tutorial

“

Das obige ist der detaillierte Inhalt vonJava-Entwurfsmuster-Analyse-Adaptermuster (detailliertes Beispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!