您的位置:首页 > 移动开发 > Android开发

设计模式大总结(四):适配器模式

2017-08-23 16:26 232 查看

前言

今天准备聊聊适配器模式,适配器模式相比之前的观察者模式或者是代理模式,我觉得思路的复杂度差不多,但是实现起来会稍微复杂一点。

适配器是什么呢?

很简单,就以我现在身边的东西:电脑的适配器,手机的适配器,我们习惯的叫他们电源。

大家都知道实际上电压都不是非常标准的220V,因为要把电输送到很远的地方,发电站提供的电压是非常高的,传输过程中还会损耗,所以我们平时使用的电压都是经过电压的转换的(例如变压器),有些对电压要求比较高的设备,例如电脑,手机,他们的电源都会有简单的电压适配。

我们就是要把这个原理带到程序中去。

正文

说到Android的适配模式,那肯定就是典型的ListView,RecyclerView的使用,你只要实现最重要的几个方法,保证转换过程的执行就OK了。如果你还没弄清楚适配模式,先继承往下看。

那么我们就来模拟一下电源从传输到使用的过程,我先画了一张原型图:



里面的描述我们每一个环节需要实现的重要功能和作用,这里就不再啰嗦了。但是从开发的角度还是要简单分析一下:

1、适配器模式,最好是以SDK开发的角度来分析,因为最终暴露给使用者的,只有基础适配器和适配器的使用者。

2、当电压发生了变化,需要通知使用做相应的调整,这里我们使用观察者模式。

接下来我们按照原型图,开始创建需要使用的类:

电压提供者类和标准的电压类:

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
*   超高电压类, 不能被耗电器直接使用
*/

public class Voltage1000 {

private int voltage;

public Voltage1000(int voltage){
this.voltage = voltage;
}

public int getVoltage(){
return this.voltage;
}

public void output() {
Log.e("lzp", "输出了" + voltage + "V的电压, 危险请勿直接使用");
}

}

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 标准的电压类,voltage可以随意设置
*/

public class Voltage {

private int voltage;

public Voltage(int voltage) {
this.voltage = voltage;
}

public void output() {
Log.e("lzp", "输出了" + voltage + "V的电压,可以供家庭使用");
}
}


适配器接口类:

/**
* Created by li.zhipeng on 2017/8/22.
*
*      电压的被观察者,用于通知电压发生了变化
*/
public class VoltageObservable extends Observable {

/**
* 通知观察者,已经发生了变化
* */
public void notifyVoltageChanged(){
setChanged();
notifyObservers();
}
}

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 这是电压的基本接口
*/

public interface VoltageImpl {

/**
* 输出电压,负责转换的过程
*/
Voltage convertVoltage(Voltage1000 voltage);
}


基础的电压适配器:

/**
* Created by li.zhipeng on 2017/8/22.
*
*      电压的基础适配器
*/

public abstract class BaseVoltageAdapter implements VoltageImpl {

/**
*
* 要输出的电压
*/
private int voltage;

/**
* 通知的回调,这里可以使用观察者模式,模仿BaseAdapter
* */
private VoltageObservable observable;

/**
* 获取当前的电压
* */
public int getVoltage() {
return voltage;
}

/**
* 设置电压
* */
public void setVoltage(int voltage) {
this.voltage = voltage;
}

/**
* 构造方法
* */
public BaseVoltageAdapter(int voltage){
this.voltage = voltage;
observable = new VoltageObservable();
}

/**
* 当电压发生了变化,通知使用者
* */
public void notifiVoltageChanged(){
observable.notifyVoltageChanged();
}

/**
* 获取被观察者
* */
public VoltageObservable getVoltageObservable(){
return this.observable;
}

}


耗电器类:

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 耗电设备类
*/

public class VoltageMachine {

/**
* 初始电压
*/
private Voltage1000 voltage1000;

/**
* 要输出电压的次数
*/
private int outputCount;

/**
* 电压的适配器
*/
private BaseVoltageAdapter baseVoltageAdapter;

/**
* 构造方法
* */
public VoltageMachine(Voltage1000 voltage1000, int outputCount){
this.voltage1000 = voltage1000;
this.outputCount = outputCount;
}

/**
* 循环输出电压
*/
public void outputVotalge() {
for (int i = 0; i < outputCount; i++) {
Voltage voltage = baseVoltageAdapter.convertVoltage(voltage1000);
voltage.output();
}
}

/**
* 设置适配器
*/
public BaseVoltageAdapter getAdapter() {
return baseVoltageAdapter;
}

/**
* 获取适配器
*/
public void setAdapter(BaseVoltageAdapter baseVoltageAdapter) {
// 先解绑之前的的被观察者
unregisterVoltageObserable();
// 设置适配器
this.baseVoltageAdapter = baseVoltageAdapter;
// 注册新的被观察者
registerVoltageObserable();

// 开始输出电压
outputVotalge();
}

/**
* 获取输出次数
*/
public int getOutputCount() {
return outputCount;
}

/**
* 设置输出次数
*/
public void setOutputCount(int outputCount) {
this.outputCount = outputCount;
}

/**
* 定义当电压发生变化的
*/
private Observer observer = new Observer() {
@Override
public void update(Observable o, Object arg) {
outputVotalge();
}
};

/**
* 注册适配器的观察者
*/
private void registerVoltageObserable() {
if (baseVoltageAdapter != null) {
baseVoltageAdapter.getVoltageObservable().addObserver(observer);
}
}

/**
* 解绑适配器的观察者
*/
private void unregisterVoltageObserable() {
if (baseVoltageAdapter != null) {
baseVoltageAdapter.getVoltageObservable().deleteObserver(observer);
}
}
}


基础的类我们已经都贴出来了,主要有以下几点需要注意以下:

1、在setAdapter时,要保证只注册了一个被观察者,否则可能会发生无用的更新,甚至程序运行的异常。

2、当耗电器使用结束,setAdapter(null),解除耦合,并且解绑被观察者。真正的开发中,防止内存泄漏这里要尤其注意。

3、个别方法使用了private,注意sdk开发时有些方法不要开放,这个尺度根据自己的需求来权衡。

ok,现在终于到了应用层的开发,这个就简单多了:

为了让打印结果好区分,我简单的重写了output方法,增加一条分隔线

/**
* Created by li.zhipeng on 2017/8/22.
*
*      这是一个大型的耗电机器
*/

public class LargePowerMachine extends VoltageMachine{

/**
* 构造方法
*
* @param voltage1000
* @param outputCount
*/
public LargePowerMachine(Voltage1000 voltage1000, int outputCount) {
super(voltage1000, outputCount);
}

/**
*  自定义输出的逻辑
* */
@Override
public void outputVotalge() {
super.outputVotalge();
// 输出结束的时候,再输出一条分界线
Log.e("lzp", "-------------------");
}
}


实现自定义的适配器:

/**
* Created by li.zhipeng on 2017/8/22.
*
*      自定义适配器类
*/

public class MyVoltageAdapter extends BaseVoltageAdapter {

/**
* 构造方法
*
* @param voltage
*/
public MyVoltageAdapter(int voltage) {
super(voltage);
}

/**
* 重写电压的转换方法
* */
@Override
public Voltage convertVoltage(Voltage1000 voltage) {
// 这里进行了电压之间的转换
// 假设这里有很多很复杂的操作
// 我这里啥也没写
return new Voltage(getVoltage());
}
}


最后是MainActivity的代码:

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// 创建一个耗电器, 初始电压是1000,需要输出5次电压
LargePowerMachine largePowerMachine = new LargePowerMachine(new Voltage1000(1000), 5);
// 添加一个适配器,这里我们需要220V的电压
final MyVoltageAdapter myVoltageAdapter = new MyVoltageAdapter(220);
largePowerMachine.setAdapter(myVoltageAdapter);

//
findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 需求发生变化,这里突然要输出100V的电压
myVoltageAdapter.setVoltage(110);
myVoltageAdapter.notifiVoltageChanged();
}
});
}
}


输出结果:



探讨适配器模式的使用场景

经过一个小demo,我们对适配器的理解又提升了一个档次,首先我们对他进行一个综合评价:

1、开发的成本比较高,为了完成适配模式,我们定义了比较多的类。

2、可以通过泛型适当的较少适配器工作量。

3、适配器模式只关心转换结果,不关心转换过程,处于整个使用过程的中间。

那么他应该在什么样的场景使用呢?我个人有以下几种理解:

1、转换源和转换结果的类型长期稳定,不能发生大的变动,通过适配器模式,为提供者提供不同的解决方案。

2、对于转换的结果比较敏感,当结果发生改变时,要及时的应对。

3、只关心转换的结果,不关心来源和如何使用。

要说平时到底哪里用的多,我现在只能想起来模块开发,其实模块开发也是SDK开发的一种,只负责提供服务,具体要什么样的结果,让使用者自己来定义,例如我提供的User信息,你想要怎么处理User都可以,与我无关。

总之,当你要开发一个稳定的模块,并且要为其他人提供相同类型的服务,我希望你能够先思考适配模式。

总结

适配模式就是这样了,应用开发这个模式我确实用的不多,如果有一天你要开发SDK了,千万别忘了他。
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息