策略模式在android中使用

“ceci”通过精心收集，向本站投稿了5篇策略模式在android中使用，以下是小编为大家整理后的策略模式在android中使用，希望对大家有所帮助。

篇1：策略模式在android中使用

策略模式（Strategy）

策略模式是对象的行为模式，它的用意是针对一组算法，将每一个算法封装到具有共同接口的独立类中，从而使得它们可以相互替换。策略模式使得算法可以在不修改或影响到调用端的情况下发生变化。

下面来讨论下策略模式的结构类图，具体如下：

从上面的结构图中，我们可以看出策略模式涉及到了三个角色，具体角色如下所示：

A、抽象策略角色：这是个抽象角色，通常是由一个接口或是抽象类来实现。它为所有的具体策略类提供了需要的接口。

B、具体策略角色：这个角色包装了相关的算法和行为，用来执行对应的策略事件。

C、环境角色：这个角色中含有一个对抽象策略类的引用，也是供外部调用直接接触的角色。

下面具体举个例子来使用策略模式。例子是这样的：现在要做一个上网使用得app，接入的网络类型有三种，分别为CMCC、ChinaNet及普通的Wifi类型，所以针对这几种类型的网络，我们需要定义一个抽象的策略角色，然后再定义三个具体角色，每个具体的角色中实现具体的功能细节，最后，我们在前端放置三个按钮，点击对应的按钮调用对应的具体角色逻辑（通过调用抽象角色）。下面为我的代码逻辑实现以及部分说明文字：

抽象策略角色（WifiConnectStrategy）：

/**

* 抽象策略角色

*/

public abstract classWifiConnectStrategyimplementsCallback{

privateWifiConnectStrategyListener listener =null;

protectedWifiState wifiState =null;

protectedHandler handler =null;

protected static final longCONN_WIFI_TIME= ; // 连接wifi的时间（模拟）

publicWifiConnectStrategy {

handler =newHandler(WifiConnectStrategy.this);

}

public voidsetWifiConnectStrategyListener(WifiConnectStrategyListener listener) {

this.listener = listener;

}

/**

* 创建一个策略，根据wifitype

*/

public staticWifiConnectStrategycreateWithWifiType(WifiType wifiType) {

WifiConnectStrategy result =null;

switch(wifiType) {

caseCMCC:

result =newCMCCWifiConnectStrategy();

break;

caseCHINANET:

result =newChinaNetWifiConnectStrategy();

break;

caseCOMMON:

result =newCommonWifiConnectStrategy();

break;

default:

break;

}

returnresult;

}

public voidconfigWifiState(WifiState wifiState) {

this.wifiState = wifiState;

}

/**

* 连接到网络的方法

*/

public abstract voidexecuteConnectNetRun();

/**

* 模拟链接后返回的结果

*/

public abstract voidconnectResult();

// 模拟网络链接延迟

protected voidsimulateConnect() {

this.handler.removeMessages(1);

this.handler.sendEmptyMessageDelayed(1,CONN_WIFI_TIME);

}

@Override

public booleanhandleMessage(Message msg) {

connectResult();

return true;

}

publicWifiConnectStrategyListener getListener() {

returnlistener;

}

public voidsetListener(WifiConnectStrategyListener listener) {

this.listener = listener;

}

public voidlog(String log) {

Log.d(WifiConnectStrategy, log);

}

}

具体策略角色（CMCC）：

/**

* 具体策略角色

*/

public classCMCCWifiConnectStrategyextendsWifiConnectStrategy {

publicCMCCWifiConnectStrategy() {

super();

}

@Override

public voidexecuteConnectNetRun() {

log(cmcc connect ...);

// 链接网络核心代码（异步）

//TODO

// 模拟网络链接延迟

simulateConnect();

}

@Override

public voidconnectResult(){

getListener().cmccConnResult(this.wifiState.getWifiLabel() +连接成功！);

}

}

具体策略角色（ChinaNet）：

public classChinaNetWifiConnectStrategyextendsWifiConnectStrategy {

publicChinaNetWifiConnectStrategy() {

super();

}

@Override

public voidexecuteConnectNetRun() {

log(chinanet connect ...);

// 链接网络核心代码

//TODO

// 模拟网络链接延迟

simulateConnect();

}

@Override

public voidconnectResult(){

getListener().cmccConnResult(this.wifiState.getWifiLabel() +连接成功！);

}

}

具体策略角色（Common wifi）：

public classCommonWifiConnectStrategyextendsWifiConnectStrategy {

publicCommonWifiConnectStrategy() {

super();

}

@Override

public voidexecuteConnectNetRun(){

log(common connect ...);

// 链接网络核心代码

//TODO

// 模拟网络链接延迟

simulateConnect();

}

@Override

public voidconnectResult(){

getListener().cmccConnResult(this.wifiState.getWifiLabel() +连接成功！);

}

}

下面为我们具体的环境角色，主要就是引用一个抽象策略角色，以及根据不同网络类型创建对应的具体策略角色，具体如下：

public classMainActivityextendsActivityimplementsOnClickListener {

privateButton btnCmcc =null;

privateButton btnChinanet =null;

privateButton btnCommon =null;

privateWifiConnectStrategy wifiConnectStrategy;

privateWifiState selectedState =newWifiState();

privateWifiConnectStrategyListener listener =newWifiConnectStrategyListener() {

@Override

public voidcmccConnResult(String state) {

log(state);

}

@Override

public voidchinanetConnResult(Stringstate) {

log(state);

}

@Override

public voidcommonConnResult(String state) {

log(state);

}

};

@Override

protected voidonCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

btnCmcc = (Button) findViewById(R.id.btnCmcc);

btnChinanet = (Button) findViewById(R.id.btnChinanet);

btnCommon = (Button) findViewById(R.id.btnCommon);

btnCmcc.setOnClickListener(this);

btnChinanet.setOnClickListener(this);

btnCommon.setOnClickListener(this);

}

@Override

public voidonClick(View v) {

if(null!= wifiConnectStrategy) {

wifiConnectStrategy =null;

}

if(v.getId() == R.id.btnCmcc) {

selectedState.setCardNo(cmcc+1167278922);

selectedState.setIpAddress(192168013);

selectedState.setPassword(123456);

selectedState.setWifiLabel(CMCC);

selectedState.setSsid(dafadfdadada);

selectedState.setWifiType(WifiType.CMCC);

wifiConnSpecial(selectedState);

}

else if(v.getId() == R.id.btnChinanet) {

selectedState.setCardNo(cmcc+1167272222);

selectedState.setIpAddress(192168433);

selectedState.setPassword(123456777);

selectedState.setWifiLabel(ChinaNet);

selectedState.setSsid(dafadeeeedada);

selectedState.setWifiType(WifiType.CHINANET);

wifiConnSpecial(selectedState);

}

else{

selectedState.setIpAddress(192168111);

selectedState.setPassword(123456789);

selectedState.setWifiLabel(COMMON);

selectedState.setSsid(dafadeeeSSDASF);

selectedState.setWifiType(WifiType.COMMON);

wifiConnCommon(selectedState);

}

}

private voidwifiConnSpecial(WifiState wifiState) {

wifiConnectStrategy = WifiConnectStrategy.createWithWifiType(selectedState.getWifiType());

wifiConnectStrategy.configWifiState(wifiState);

wifiConnectStrategy.setWifiConnectStrategyListener(listener);

wifiConnectStrategy.executeConnectNetRun();

}

private voidwifiConnCommon(WifiState wifiState) {

wifiConnectStrategy = WifiConnectStrategy.createWithWifiType(selectedState.getWifiType());

wifiConnectStrategy.configWifiState(wifiState);

wifiConnectStrategy.setWifiConnectStrategyListener(listener);

wifiConnectStrategy.executeConnectNetRun();

}

private voidlog(String log) {

Log.d(WifiConnectStrategy,log);

}

}

注意：这里的WifiState类为wifi的封装类，WifiConnectStrategyListener为监听网络链接的接口，

接下来，我会在下面罗列出他们的代码构成。

WifiState:

public classWifiState {

//wifiname

privateString wifiLabel;

//wifi ip

private intipAddress;

//wifi ssid

privateString ssid;

//wifipassword

privateString password;

// card no

privateString cardNo;

// 类型

privateWifiType wifiType;

//wifi类型

public enumWifiType {

CMCC(1),

CHINANET(2),

COMMON(3);

private final inttype;

privateWifiType(inttype) {

this.type = type;

}

public intgetType() {

returntype;

}

public staticWifiTypegetType(intwifiType) {

WifiTypetype =null;

if(WifiType.CMCC.getType() == wifiType) {

type = WifiType.CMCC;

}

else if(WifiType.CHINANET.getType() == wifiType) {

type = WifiType.CHINANET;

}

else if(WifiType.COMMON.getType() == wifiType) {

type = WifiType.COMMON;

}

returntype;

}

}

public intgetIpAddress() {

returnipAddress;

}

public voidsetIpAddress(intipAddress) {

this.ipAddress = ipAddress;

}

publicString getSsid() {

returnssid;

}

public voidsetSsid(String ssid) {

this.ssid = ssid;

}

publicString getPassword() {

returnpassword;

}

public voidsetPassword(String password) {

this.password = password;

}

publicString getCardNo() {

returncardNo;

}

public voidsetCardNo(StringcardNo) {

this.cardNo = cardNo;

}

publicString getWifiLabel() {

returnwifiLabel;

}

public voidsetWifiLabel(String wifiLabel) {

this.wifiLabel = wifiLabel;

}

publicWifiType getWifiType() {

returnwifiType;

}

public voidsetWifiType(WifiType wifiType) {

this.wifiType = wifiType;

}

}

WifiConnectStrategyListener:

/**

*wifi链接的监听

*/

public interfaceWifiConnectStrategyListener {

public voidcmccConnResult(String state);

public voidchinanetConnResult(String state);

public voidcommonConnResult(String state);

}

好了，运行下代码，页面效果如下：

当我们点击对应的按钮链接网络时，会在输出日志打印对应的wifi链接以及链接成功，当然，这是只是模拟实现，实际上整个过程没这么简单，比如需要先获得卡号，然后异步链接，获得返回的信息，链接是否成功等。

日志如下：

好了，到这里，策略模式的介绍就完成了，稍后会把项目代码上传，希望对大家有帮助。

篇2：观察者模式在android中使用

观察者模式（Observer）

观察者模式是对象的行为模式，又被叫做为模型-视图模式，这种模式定义了一种一对多的依赖关系，使多个观察者对象同时监听某个角色对象。一旦这个角色对象的状态发生了变化，就会通知所有观察者对象，使它们能够自动更新自己本身。

下面来看下观察者模式的结构，具体如下：

从上面图中可以看出，观察者模式涉及了四个角色，具体如下所示：

A、抽象实体角色：这个角色为抽象角色，它把所有的对观察者对象的引用都保存在一个聚集中，每个主题对象都可以有若干个观察者对象，主题角色又叫做抽象被观察者对象，一般用抽象类或接口表示。

同时，这个角色中含有了对观察者具体的管理方法及当主题角色发生改变时通知所有观察者对象。

B、具体实体角色：这个角色为具体实现了抽象的实体角色的具体角色。它含有了一个对实体角色状态的引用，一但实体角色改变，那么就会调用通知方法通知所有观察者对象。

C、抽象观察者对象：这个角色为所有的具体的观察者对象提供通用的接口，在得到实体变化的通知时实时的更新自己，这个角色一般用抽象类和接口来实现。

D、具体观察者对象：将有关的状态放到具体观察者对象中，在具体主题的内部的状态改变时，给所有的观察者发送通知。该角色又叫做为具体被观察者角色。

下面具体举例来说明观察者模式的使用。例子是这样的：用户现在要购买若干件同一品牌的不同款式的衣服，假如用户已经选好了不同款式的衣服，现需要实现添加到购物车并支付；支付成功之后，现在需要及时刷新用户的购物车，以便用户可以及时知道自己支付的结果，方便从新支付或挑选其他款式并支付。好了，具体需要描述完了，接下来请看功能详细类图说明：

下面直接看代码吧！我会在下面列出观察者模式的核心代码，其他请参看我上传的项目代码包，具体如下：

抽象实体角色（Cart）：

/**

*@description:

* 抽象实体角色－观察者关注的对象实体

*/

public abstract classCart {

privateVectorobservers =newVector();

publicCart() {

super();

}

/**

*@description:

* 登记一个观察者对象

*/

public voidattach(SalesObserver observer) {

observers.addElement(observer);

}

/**

*@description:

* 删除一个已经登记的观察者对象

*/

public voiddetach(SalesObserver observer) {

observers.removeElement(observer);

}

public voiddetach(intindex) {

observers.remove(index);

}

/**

*@description:

* 通知所有已经登记过的观察者对象

*/

public voidnotifyAllBills(){

Enumerationenumes = observers();

while(enumes.hasMoreElements()){

SalesObserverobj = (SalesObserver)enumes.nextElement();

obj.updateSale(obj);

}

}

/**

*@description:

* 支付成功之后，更新购物车内的所有商品的支付状态

* 注意：这里更新的是本地缓存数据（不通过接口更新）

*/

public booleanbillsPay() {

booleanpayStatus =true;

// 异步网络支付

//TODO

// 这里模拟支付成功

if(payStatus) {

// 更新本地缓存数据

updateLocalCache();

}

return true;

}

/**

*@description:

* 更新缓存

*/

private voidupdateLocalCache() {

for(SalesObserver obs : observers) {

Salesale = obs.getSale();

sale.setPayStatus(支付完成);

}

}

publicEnumerationobservers() {

returnobservers.elements();

}

}

具体实体角色（ShoppingCart）：

/**

*@description:

* 具体的实体角色－具体通知各个观察者对象更新状态

*/

public classShoppingCartextendsCart {

publicShoppingCart() {

super();

}

protected voidbillPayResult(booleanflag) {

if(!flag) {

// 支付失败提示（这里不考虑这种情况）

return;

}

// notifyobervers

notifyAllBills();

}

}

抽象观察者角色（Observer）：

/**

*@description:

* 抽象观察者－为所有具体观察者提供更新方法

*/

public interfaceObserver{

publicObject updateSale(Object obj);

}

具体观察者角色（SalesObserver）：

/**

*@description:

* 具体观察者－具体执行更改状态的操作

*/

public classSalesObserverimplementsObserver {

privateSale sale =null;

publicSalesObserver(Sale sale) {

this.sale = sale;

}

@Override

publicObject updateSale(Object obj) {

this.sale = (Sale) obj;

returnsale;

}

publicSale getSale() {

returnsale;

}

public voidsetSale(Sale sale) {

this.sale = sale;

}

}

好了，核心的代码已经贴上了，下面会列出整个流程的演示效果图：

添加购物车：

移除购物车：

支付之后效果（之前购物车和移除购物车效果相同略）：

篇3：适配器模式在android中使用

适配器模式（Adapter）：

适配器模式是一种行为模式，它可以把一个类的接口转换成为另一个所期待的另一种接口，这样可以使原本因接口无法在一起工作的两个类能够在一起工作了，适配器模式有类的适配器和对象的适配器两种形式，这里只介绍对象的适配器模式（与类适配器模式类似），下面为类的适配器（左）和对象适配器模式（右）的简略类图结构：

适配器模式所涉及的角色有适配角色、目标角色和适配器角色，具体描述如下：

适配角色：提供需要适配转换的接口角色。

目标角色：调用者所期待的接口。

适配器角色：把适配角色转为目标角色的接口。

与之前一样，我们同样列举一个实例来说明适配器模式的使用。在电商平台中，查询商品、查看商品详情、添加购物车和支付是最常见不过了。假如原系统中已经实现了商品的查询、添加购物车以及支付功能，查询功能包括查询商品、查看详情、以及计算商品总价；添加购物车包括查看详情、商品添加购物车以及支付，目前这两个模块功能是不协同工作的，所以下面我们将会把购物车适配成为可以与查看商品一起工作，实现他们的一体化操作。那么他们的详细结构类图如下所示：

好了，下面罗列下适配器模式的核心代码。

目标角色（SaleShopCenter）：

/**

*@description:

* 目标对象

*/

public interfaceSaleShopCenter {

ListscanSaleItems(String pKey);

SalescanSaleDetail(String pId);

doublecalculateTotalPrice;

}

适配角色（ShoppingCart）：

/**

*@description:

* 适配的对象

*/

public classShoppingCart {

privateSalesale =null;

public staticListresults=null; // 模拟缓存数据ß

publicSale scanSaleDetail(StringpId) {

// 异步请求网络

//TODO

// 这里模拟实现

sale = getSale(pId);

returnsale;

}

public voidaddSaleShoppingCart(Listsales) {

// 异步请求网络

//TODO

addCart(sales);

}

public booleanbillPay(Listsales) {

// 异步请求网络

//TODO

// 这里模拟支付成功

booleanpayStatus =true;

if(null==SaleShoppingManager.results

||0 >SaleShoppingManager.results.size()) {

payStatus =false;

}

returnpayStatus;

}

privateSale getSale(StringpId) {

if(null==SaleShoppingManager.results

||0 >SaleShoppingManager.results.size()) {

return null;

}

Salesale =null;

for(Saleitem : SaleShoppingManager.results) {

if(item.getpID().equals(pId)) {

sale = item;

}

}

returnsale;

}

private voidaddCart(Listsales) {

results= sales;

}

}

适配器角色（SaleShoppingManager）：

/**

*@description:

* 适配器对象角色

*/

public classSaleShoppingManagerimplementsSaleShopCenter {

privateShoppingCartcart =null;

public staticListresults=null; // 模拟缓存数据

publicSaleShoppingManager() {

cart =newShoppingCart();

}

@Override

publicListscanSaleItems(StringpKey) {

results=newArrayList();

// 异步网络请求

//TODO

// 这里模拟实现

results= getSales();

returnresults;

}

@Override

publicSale scanSaleDetail(StringpId) {

returncart.scanSaleDetail(pId);

}

@Override

public doublecalculateTotalPrice() {

if(null==results|| 0 >results.size()) {

return0;

}

doubletotalPrice = 0;

for(Salesale :results) {

totalPrice += sale.getpPrice();

}

returntotalPrice;

}

privateListgetSales() {

Listresult =newArrayList();

Salesale =newSale();

sale.setpID(0000121300);

sale.setbID(1111232300);

sale.setpName(衬衫－黑领);

sale.setpPrice(123.14);

sale.setpDescri(黑色、圆领，高端大气！);

result.add(sale);

Salesale2 =newSale();

sale2.setpID(0000121311);

sale2.setbID(1111232311);

sale2.setpName(衬衫－黑领);

sale2.setpPrice(123.34);

sale2.setpDescri(黑色、圆领，高端大气！);

result.add(sale2);

Salesale3 =newSale();

sale3.setpID(0000121322);

sale3.setbID(1111232322);

sale3.setpName(衬衫－黑领22);

sale3.setpPrice(123.24);

sale3.setpDescri(黑色、圆领，高端大气！);

result.add(sale3);

returnresult;

}

publicShoppingCart getCart() {

returncart;

}

}

下面为程序的运营结果图，后面我会上传项目代码，感兴趣的同学可以下载跑跑，

效果图如下：

好了，到这里适配器模式已经介绍完了。

篇4：在Vista中使用兼容模式运行应用程序

不少朋友在升级到Windows Vista后，却因所使用的应用程序在Windows Vista中不能正常工作而不得不退回到Windows XP，浪费时间不说，也让自己只能望Windows Vista众多诱人的功能与特性而兴叹，

其实，如果您打算升级到Windows Vista的话，除了首先检查通过Windows Vista认证的软件列表，查看您所使用的应用程序是不是通过了微软的“Certified for Windows Vista”或“Works with Windows Vista”认证，或者您的应用程序是不是有新的升级版本以兼容于Windows Vista外，还要清楚一点，即使不兼容于Windows Vista的应用程序，也可以在Windows Vista中正常使用，那便是通过兼容模式(Compatibility Mode)运行。

从技术上讲，兼容模式并不是一项新技术，在微软上一版本的操作系统Windows XP便已提供了这一功能，以解决早期版本程序无法正常运行的问题。不过，相比较而言，Windows Vista中的程序兼容模式似乎有了不小的改进，用户可进行更详细的设置，同时，适应性更强。

设置应用程序使用兼容模式运行

如果您的应用程序在Windows vista中运行不正常，可按如下的步骤设置使用兼容模式运行，以可以解决绝大多数的兼容性问题。另外，需要提醒的是，兼容模式不仅针对应用程序本身，也可针对应用软件的安装程序，即如果某个软件在Windows vista中不能正常安装的话，也可以通过设置兼容模式使之完成安装。

启动资源管理器，在应用程序执行文件上单击鼠标右键，选择属性；

转到“兼容性”标签页；

注：如果“兼容性”标签页为灰色不可选，往往由于您选择的执行文件并非.exe而是.msi文件(如MS Office安装文件)，对这种情况，您需要找到真正的.exe执行文件，简单办法便是通过任务管理器，即启动该程序，然后按“Ctrl+ Alt + Del”组合键打开任务管理器，在进程窗口下找到相应对象后查看右键属性，

勾选“用兼容模式运行这个程序”选项；

在其下的下拉菜单中，您可以选择要兼容的操作系统版本，包括 Windows 95、Windows 98/ME、Windows NT4.0 SP 5、Windows 、Windows XP SP2 以及 WIndows SP1，对于大多数情况而言，选择 Windows XP SP 2 应该就可以了；

您还可以根据应用程序的运行需求选择颜色、屏幕分辩率甚至禁用桌面元素、禁用桌面缩放等；

至于“请以管理员身份运行该程序”项，最好不要勾选，以带来不必要的安全隐患。当然，如果未选该项程序仍不能在Windows Vista正常运行，您可在稍后尝试启用该项；

下图即在Windows Vista中运行Microsoft Word 2003时设置兼容模式的示例：

点击确定。

如此，即大功告成，您会发现原来在Windows Vista中频发故障的旧版应用程序可以在Windows Vista中正常运行了。

篇5：在大学英语课堂中培养学生使用元认知策略的能力

在大学英语课堂中培养学生使用元认知策略的能力

元认知策略是提高学生英语学习成绩和发展自主学习能力的关键.本文以简述Flavell的元.认知理论和元认知策略为基础,指出从以下三方面在大学英语课堂中培养学生使用元认知策略的能力:对学习者进行元认知策略知识的传授;对学习者进行元认知策略的.训练;元认知策略和社会、情感策略的关系.