Analisis Corak Reka Bentuk Java: Cara Melaksanakan Corak Penyesuai

1 Apakah corak penyesuai:

Corak penyesuai digunakan terutamanya untuk menukar antara muka kelas kepada apa. yang dikehendaki oleh pelanggan. Format kelas sasaran membolehkan kelas asal yang tidak serasi berfungsi bersama, memisahkan kelas sasaran dan kelas penyesuai, ia juga mematuhi "prinsip pembukaan dan penutup", dan kelas penyesuai baharu boleh ditambah tanpa mengubah kod asal; Merangkum pelaksanaan khusus dalam kelas penyesuai adalah telus kepada kelas pelanggan dan meningkatkan kebolehgunaan semula penyesuai Walau bagaimanapun, kelemahannya ialah proses pelaksanaan menggantikan penyesuai adalah rumit.

Jadi, corak penyesuai lebih sesuai untuk senario berikut:

• (1) Sistem perlu menggunakan kelas sedia ada, dan antara muka kelas ini tidak mematuhi antara muka sistem.

• (2) Apabila menggunakan komponen pihak ketiga, definisi antara muka komponen berbeza daripada definisi anda sendiri Anda tidak mahu mengubah suai antara muka anda sendiri, tetapi anda mesti menggunakan fungsi antara muka komponen pihak ketiga.

Dua contoh yang sangat jelas berikut menggambarkan dengan baik apakah corak penyesuai:

2. Tiga cara untuk melaksanakan corak penyesuai:

Corak penyesuai terbahagi terutamanya kepada tiga kategori: corak penyesuai kelas, corak penyesuai objek dan corak penyesuai antara muka.

1. Corak penyesuai kelas:

• Antara Muka Sasaran (Sasaran): Antara muka yang pelanggan harapkan. Sasaran boleh menjadi kelas konkrit atau abstrak, atau antara muka.

• Kelas yang perlu disesuaikan (Adaptee): Kelas yang perlu disesuaikan atau kelas penyesuai.

• Penyesuai: Menukar antara muka asal kepada antara muka sasaran dengan membungkus objek yang perlu disesuaikan.

// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
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();
	}
}

Hasil berjalan:

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

2 Mod penyesuai objek:

// 适配器类，直接关联被适配类，同时实现标准接口
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();
	}
}

Keputusan ujian adalah konsisten dengan perkara di atas. Daripada rajah kelas, kita juga tahu bahawa semua yang perlu diubah suai adalah struktur dalaman kelas Penyesuai, iaitu, Penyesuai itu sendiri mesti terlebih dahulu mempunyai objek kelas yang disesuaikan, dan kemudian mewakilkan fungsi khas khusus kepada objek ini untuk pelaksanaan. Menggunakan mod penyesuai objek, kelas Penyesuai (kelas penyesuaian) boleh menyesuaikan diri dengan berbilang kelas disesuaikan yang berbeza berdasarkan objek Penyesuai yang masuk Sudah tentu, pada masa ini kita boleh mengekstrak antara muka untuk beberapa kelas yang disesuaikan atau kelas abstrak. Nampaknya mod penyesuai objek lebih fleksibel.

3. Corak penyesuai antara muka:

Kadang-kadang terdapat berbilang kaedah abstrak dalam antara muka yang kita tulis Apabila kita menulis kelas pelaksanaan antara muka, ia mestilah dilaksanakan Semua kaedah antara muka ini, yang jelas kadang-kadang membazir, kerana tidak semua kaedah adalah apa yang kita perlukan, kadang-kadang hanya beberapa yang diperlukan Untuk menyelesaikan masalah ini, kami memperkenalkan mod penyesuai antara muka, dengan bantuan abstrak class , kelas abstrak ini melaksanakan antara muka dan semua kaedah, dan kami tidak berurusan dengan antara muka asal, hanya berhubung dengan kelas abstrak, jadi kami menulis kelas, mewarisi kelas abstrak, dan menulis semula kaedah yang kami perlukan. Lihat gambar rajah kelas:

Ini mudah difahami Dalam pembangunan sebenar, kita sering menghadapi terlalu banyak kaedah yang ditakrifkan dalam antara muka ini, sehingga kadangkala kita Tidak semua diperlukan dalam beberapa kelas pelaksanaan. Lihat kod:

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

Pembungkus kelas abstrak2:

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();
	}
}

Hasil berjalan:

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

Atas ialah kandungan terperinci Analisis Corak Reka Bentuk Java: Cara Melaksanakan Corak Penyesuai. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!