适配器设计模式(adapter pattern)

描述： 适配器设计模式主要用于接口的转化或者将接口不兼容的类对象组合在一起形成对外统一的接口，是一种结构性模式其本质是一种中间件，适用于类和对象。

核心思想： 对现有的接口进行转化以符合新的需求

使用场景：

  • 想用一个已经存在的类，但其接口不符合需求；
  • 想创建一个可以复用的类，该类可以与其他不相关的类协同工作；
  • 想使用一些已经存在的子类，但是不能对每一个都进行子类化以匹配它们的接口（仅适用于对象Adapter）。对象适配器可以适配他的父类接口。

适配器设计模式的优点：

  • 提高了类的复用；
  • 组合若干关联对象形成对外提供统一服务的接口；
  • 扩展性、灵活性好。

适配器设计模式的缺点：

  • 过多使用适配模式容易造成代码功能和逻辑意义的混淆。
  • 部分语言对继承的限制，可能至多只能适配一个适配者类，而且目标类必须是抽象类。

适配器设计模式的分类：

  • 类适配器
  • 对象适配器
  • 接口适配器

示例：

类适配器
  • 定义目标接口类：Target
1
2
3
public interface Target {
    void request();
}
  • 被适配的类：Adaptee
1
2
3
4
5
public class Adaptee {
    public void adapteeRequest() {
        System.out.println("adapteeRequest method of Adaptee! ");
    }
}
  • 适配类Adapter，实现Target的接口request，同时继承Adaptee的实现adapteeRequest
1
2
3
4
5
6
7
public class Adapter extends Adaptee implements Target {
    @Override
    public void request() {
        // TODO Auto-generated method stub
        super.adapteeRequest();
    }
}
  • 调用
1
2
3
4
5
6
public class Demo {
    public static void main(String [] args) {
        Target target = new Adapter();
        target.request(); // result: adapteeRequest method of Adaptee! 
    }
}
对象适配器
  • 对象适配器和类适配器的主要区别就是类适配器的适配器类是继承被适配的类，对象适配器的适配器类是依赖被适配的类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 适配器
 */
public class Adapter implements Target {
 
    private Adaptee adaptee;
 
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
 
    public void operation1() {
        adaptee.operation1();
    }
 
    public void operation2() {
        System.out.println("operation2");
    }
}
  • 调用
1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new Adapter(adaptee);
        Client client = new Client();
        client.use(adapter);
}
public void use(Target target){
        target.operation1();

接口适配器

  • 核心思路：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求

  • 使用场景： 适用于一个接口不想使用其所有的方法的情况。

  • 定义目标接口类：Target

1
2
3
4
5
6
public interface Interface4 {
	public void m1();
	public void m2();
	public void m3();
	public void m4();
}
  • 定义一个适配的中间抽象类 默认实现目标接口 以便它的子类有选择的实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class AbsAdapter implements Interface4 {

	//默认实现
	public void m1() {
	}

	public void m2() {
	}

	public void m3() {
	}

	public void m4() {
	}
}
  • 调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {
	public static void main(String[] args) {
		
		AbsAdapter absAdapter = new AbsAdapter() {
			//只需要去覆盖我们 有需要地使用 接口方法
			@Override
			public void m1() {
				// TODO Auto-generated method stub
				System.out.println("使用了m1的方法");
			}
		};
		
		absAdapter.m1();
	}
}