设计模式之策略模式课件ppt(45张)
设计模式之策略模式
前言：从很多方面来看，本课程实际上是在复述我自己学习和使用设计模式的经历，同很多大师一样，先掌握模式本身，再学习模式背后的思想，然后，又将这种理解扩展、延伸、复用、改进……但是现在回想起来，我发现自己那时大多都是遵循大多数前辈的建议行事，但并未理解面向对象的设计全部威力，直到开始学习设计模式，我们的面向对象设计能力才得以扩展和加强。
一开始就不可收拾，对设计模式着了迷，很喜欢研究别人的模式，很喜欢分析和比较，因为只有分析和比较才能领悟出新的东西，在叹服别人思想的闪光点的时候，自己也在思考。
同时，还注意到很多刚从事面向对象设计的人通过对设计模式的练习和领悟，写出的程序居然和大师级人物不相上下。
设计模式更多的展示了优秀的的面向对象设计实例，阐明了基本面向对象设计原则，而这些对于初学者更快设计出成熟的方案大有帮助。
一次又一次的思索，一次又一次的改进，我发现，使用思想作为武器，一段代码，写上20遍，收获是越来越多的，就像秦始皇统一六国的感觉，越来越美妙，妙不可言。
我已经完全相信：设计模式是面向对象发明以来在软件设计领域出现的最伟大的东西。
还有一个发现就是，一般专家容易建议先学习面向对象，打好基础，然后开始研究设计模式，但是在我的研究中，如同我研究设计模式一样，我惊讶的发现，在学习面向对象的同时，学习设计模式的学生，往往能够更好的适应工作要求，比仅仅学习面向对象的学生进步更快，而且，他们对面向对象设计模式的掌握从经验、熟练度上说几乎和老手一样（估计这也是很多老手反对的一个原因吧）。
课程对象：1.掌握C#基本语法的初学者2.想提升面向对象理解的学友3.想学习软件架构思想的工作者4.职业发展陷入瓶颈的大牛5.想掌握软件设计的思考者6.有思想、有准备的人7.想去大公司成功应聘的求职者8.想提升自己收入的白领9.想积累软件开发和设计经验的饿汉10.所有懂得欣赏面向对象思想的同仁课程安排：1.面向对象基础：从本质上告诉你什么叫封装、继承、多态，他们在内存的7个区域上是怎么分配的？语言本身做了些什么而编译器又做了些什么？这些编译后的IL语言各是什么含义？怎么认清他们的本质？从类到对象都经历了哪些复杂的过程？是不是也和婴儿一样经历了怀胎、分娩的过程？继承到底在内存上是怎么分配的？堆栈上的方法表是如何维护的？重载是如何区分的？晚绑定和编译时绑定的区别是什么？2、设计模式六大原则：开闭原则仅仅是对修改开放那么简单吗？职责单一原则这个职责单一的标准是什么？是功能？是业务？都不是……依赖倒置是怎么回事？聚合和组合以及继承到底该怎么用？里氏替换到底替换了谁？为什么要替换？3.单例方法模式：对系统说：“你是我的唯一”。
策略模式PPT课件
总结பைடு நூலகம்
• 在下面的情况下应当考虑使用策略模式： • 1. 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略
模式可以动态地让一个对象在许多行为中选择一种行为。 • 2. 一个系统需要动态地在几种算法中选择一种。那么这些算法可以包装到一个个的具
体算法类里面，而这些具体算法类都是一个抽象算法类的子类。换言之，这些具体算法 类均有统一的接口，由于多态性原则，客户端可以选择使用任何一个具体算法类，并只 持有一个数据类型是抽象算法类的对象。 • 3. 一个系统的算法使用的数据不可以让客户端知道。策略模式可以避免让客户端涉及 到不必要接触到的复杂的和只与算法有关的数据。 • 4. 如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条 件选择语句来实现。此时，使用策略模式，把这些行为转移到相应的具体策略类里面， 就可以避免使用难以维护的多重条件选择语句，并体现面向对象设计的概念。
策略模式的结构
• 策略模式是对算法的包装，是把使用算法的责任和算法本身分割开，委派给不同的对象管理。 • 策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，
就是："准备一组算法，并将每一个算法封装起来，使得它们可以互换。"
第1页/共13页
策略模式(strategy)机构图
第3页/共13页
具体案例
• 下面的例子利用策略模式在排序对象中封装了不同的排序算法，这样以便允许客户端动态的替换排序策略 （包括Quicksort、Shellsort和Mergesort）。
第4页/共13页
抽象策略
• // "Strategy" abstract class SortStrategy { // Methods abstract public void Sort( ArrayList list ); }
设计模式之策略模式浅谈以及简单例子
设计模式之策略模式浅谈以及简单例⼦设计模式之策略模式策略模式定义了算法类，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独⽴于使⽤算法的客户。
策略模式是对算法的包装，是把使⽤的责任和算法本⾝分割开来，委派给不同的对象管理。
策略模式通常把⼀个系列的算法包装到⼀系列的策略类⾥⾯，作为⼀个抽象策略类的⼦类。
策略模式涉及到三个⾓⾊：环境（Context）⾓⾊：持有⼀个Strategy的引⽤，也称策略上下⽂。
抽象策略（Strategy）⾓⾊：这是⼀个抽象⾓⾊，通常使⽤抽象类或者接⼝来实现。
此⾓⾊给出所有的具体策略类所需要的接⼝。
具体策略（ConcreteStrategy）⾓⾊：此⾓⾊包装了所有的算法和⾏为。
Eg：商场搞促销，促销⽅式有打折、满100减50等。
在本例中，抽象策略⾓⾊⽤⼀个结果实现，接⼝中有⼀个计算价格的⽅法。
接⼝实现如下：1namespace Strategy_Pattern23 {45///<summary>67///策略接⼝89///</summary>1011interface IPromotion1213 {1415///<summary>1617///根据原价和策略计算新价格1819///</summary>2021///<param name="originalPrice">原价</param>2223///<returns></returns>2425double GetPrice(double originalPrice);2627 }2829 }具体策略⾓⾊有两个，分别表⽰打折类和满100减50，都实现策略接⼝。
打折类实现如下：1 using System;2345 namespace Strategy_Pattern67 {89 /// <summary>1011 /// 打折策略类1213 /// </summary>1415 class Discount : IPromotion1617 {181920212223 #region Public Methods2425 public double GetPrice(double originalPrice) 2627 {2829 Console.WriteLine("打⼋折");3031 return originalPrice * 0.8;3233 }3435 #endregion36373839 }4041 }满100减50类实现如下：/// <summary>/// 返现策略类：满100返50/// </summary>class MoneyBack : IPromotion{#region Public Methodspublic double GetPrice(double originalPrice){Console.WriteLine("满100返50");return originalPrice - (int)originalPrice / 100 - 50; }#endregion}环境（Context）⾓⾊类如下：/// <summary>/// 策略上下⽂类/// </summary>class PromotionContext{#region Fieldsprivate IPromotion m_promotion = null;#endregion#region Constructorspublic PromotionContext(IPromotion iPromotion){this.m_promotion = iPromotion;}#endregion#region Public Methods/// <summary>/// 默认策略⽅法/// </summary>/// <param name="originalPrice"></param>/// <returns></returns>public double GetPrice(double originalPrice){if (this.m_promotion == null){this.m_promotion = new Discount();}return this.m_promotion.GetPrice(originalPrice);}/// <summary>/// 更改策略的⽅法/// </summary>/// <param name="iPromotion"></param>public void ChangePromotion(IPromotion iPromotion){this.m_promotion = iPromotion;}#endregion}然后再主类中调⽤相应的策略，主类实现如下：class Program{static void Main(string[] args){//默认策略：打⼋折的策略PromotionContext promotionContext=new PromotionContext(null);Console.WriteLine(promotionContext.GetPrice(300));//更改策略：满100减50的策略promotionContext.ChangePromotion(new MoneyBack()); Console.WriteLine(promotionContext.GetPrice(100));Console.ReadLine();}}。
设计模式之策略模式课件(PPT 45张)
目
录
1 2 3 4 5
• Contents
定义和角色
结构示意图
示例代码 实例说明 优缺点和环境
定义和角色
结构示意图 示例代码 实例说明 优缺点和环境
ContreteStrategyA +algorithmInterface():void
Context
-strategy:Strategy <create> +Context(aSteategy:Strategy) +contextInterface():void
设计模式之策略模式
主讲人 ：成 玉 丹 间：2016.11.14
时
目
录
1
定义和角色 结构示意图 示例代码
实例说明
• Contents
2 3 4 5
优缺点环境
定义和角色
结构示意图 示例代码 实例说明 优缺点和环境
定义：
策略模式定义了一系列的算法，并将每一个
算法封装起来，而且使它们还可以互相替换。策 略模式让算法独立于使用它的客户而独立变化。
• Contents
定义和角色
结构示意图
示例代码 实例说明
优缺点和环境
1、策略接口：定义算法的接口：
定义和角色
结构示意图 示例代码 实例说明 优缺点和环境
/** *策略：定义算法的接口 */
public interface Strategy{ /** *某个算法的接口，可以有传入参数，也可以有返回值 */
<interface> Strategy +algorithmInterface():void
ContreteStrategyB +algorithmInterface():void
设计模式——策略模式
设计模式——策略模式⼀、定义与简单实现1、定义策略模式的定义包含三点：定义⼀类算法（接⼝）。
封装每个算法（实现类）。
这类算法的算法可互相替换（实现类之间可互相替换）。
2、UML类图前两点已经成了我们的职业习惯（项⽬中⼀般都是⼀接⼝对应⼀实现类），重点是要弄清楚后⾯的算法互相替换，这个替换是在哪⾥实现的，需要达到什么效果?下⾯是⼀个简单的策略模式的UML图。
定义⼀类算法（接⼝FlyBehavior）封装每个算法（实现类CanFly + NotFly）Duck中定义⼀个FlyBehavior变量，然后运⽤组合的⽅式，CanFly、NotFly可以互换定义算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独⽴于使⽤算法的客户，使Duck与Fly()解耦，运⽤的设计模式原则：封装变化多⽤组合，少⽤继承针对接⼝编程，不针对实现编程3、简单代码实现/** 飞翔⾏为*/public interface FlyBehavior {void fly();}public class CanFly implements FlyBehavior {@Overridepublic void fly() {System.out.println("I can fly!");}}public class NotFly implements FlyBehavior{@Overridepublic void fly() {System.out.println("I cant fly!");}}/** 叫声*/public interface QuackBehavior {void quack();}public class GaGa implements QuackBehavior{@Overridepublic void quack() {System.out.println("ga ga ...");}}public class GuaGua implements QuackBehavior {@Overridepublic void quack() {System.out.println("gua gua ...");}}public class NotQuack implements QuackBehavior {@Overridepublic void quack() {System.out.println("...... ??");}}/** 鸭⼦*/public interface DuckInterface {void swim();void display();void performFly();void performQuack();void setFlyBehavior(FlyBehavior flyBehavior);void setQuackBehavior(QuackBehavior quackBehavior); }public class Duck implements DuckInterface {private FlyBehavior flyBehavior;private QuackBehavior quackBehavior;@Overridepublic void swim() {System.out.println("I am swimming!");}@Overridepublic void display() {System.out.println("I have white feathers!");}@Overridepublic void performFly() {if (flyBehavior == null){System.out.println("no flyBehavior!");return;}flyBehavior.fly();}@Overridepublic void performQuack() {if (quackBehavior == null){System.out.println("no quackBehavior!");return;}quackBehavior.quack();}@Overridepublic void setFlyBehavior(FlyBehavior flyBehavior) {this.flyBehavior = flyBehavior;}@Overridepublic void setQuackBehavior(QuackBehavior quackBehavior) {this.quackBehavior = quackBehavior;}}public class Main {public static void main(String[] args) {FlyBehavior canFly = new CanFly();FlyBehavior notFly = new NotFly();//⼀个会飞的鸭⼦DuckInterface duck = new Duck();duck.setFlyBehavior(canFly);duck.performFly();//现在翅膀断了duck.setFlyBehavior(notFly);duck.performFly();}}⼆、框架中的策略模式框架中实现最明显的就是Mybatis中的执⾏器Executor，UML图虽然与给出的标准的策略模式UML有所差异，但是实现的效果⼀致。
设计模式之策略模式（Strategy）详解及代码示例
设计模式之策略模式（Strategy）详解及代码⽰例⼀、策略模式的定义 策略（Strategy）模式的定义：该模式定义了⼀系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使⽤算法的客户。
策略模式属于对象⾏为模式，它通过对算法进⾏封装，把使⽤算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进⾏管理。
⼆、策略模式优缺点 策略模式的主要优点如下。
多重条件语句不易维护，⽽使⽤策略模式可以避免使⽤多重条件转移语句。
符合开闭原则，可以在不修改原代码的情况下，灵活增加新算法。
算法使⽤和实现隔离分离，提⾼算法的保密性和安全性。
策略模式提供了⼀系列的可供重⽤的算法族，恰当使⽤继承可以把算法族的公共代码转移到⽗类⾥⾯，从⽽避免重复的代码。
策略模式可以提供相同⾏为的不同实现，客户可以根据不同时间或空间要求选择不同的。
其主要缺点如下。
客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
策略模式造成很多的策略类。
三、策略模式的结构与实现 策略模式是准备⼀组算法，并将这组算法封装到⼀系列的策略类⾥⾯，作为⼀个抽象策略类的⼦类。
策略模式的重⼼不是如何实现算法，⽽是如何组织这些算法，从⽽让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现⽅法。
策略模式的主要⾓⾊如下。
抽象策略（Strategy）类：定义了⼀个公共接⼝，各种不同的算法以不同的⽅式实现这个接⼝，环境⾓⾊使⽤这个接⼝调⽤不同的算法，⼀般使⽤接⼝或抽象类实现。
具体策略（Concrete Strategy）类：实现了抽象策略定义的接⼝，提供具体的算法实现。
环境（Context）类：持有⼀个策略类的引⽤，最终给客户端调⽤。
其结构图如图所⽰： 代码实现如下：public class StrategyPattern{public static void main(String[] args){Context c=new Context();Strategy s=new ConcreteStrategyA();c.setStrategy(s);c.strategyMethod();System.out.println("-----------------");s=new ConcreteStrategyB();c.setStrategy(s);c.strategyMethod();}}//抽象策略类interface Strategy{public void strategyMethod(); //策略⽅法}//具体策略类Aclass ConcreteStrategyA implements Strategy{public void strategyMethod(){System.out.println("具体策略A的策略⽅法被访问！");}}//具体策略类Bclass ConcreteStrategyB implements Strategy{public void strategyMethod(){System.out.println("具体策略B的策略⽅法被访问！");}}//环境类class Context{private Strategy strategy;public Strategy getStrategy(){return strategy;}public void setStrategy(Strategy strategy){this.strategy=strategy;}public void strategyMethod(){strategy.strategyMethod();}} 测试结果如下：具体策略A的策略⽅法被访问！-----------------具体策略B的策略⽅法被访问！ 如下补充⼀个促销策略模式：interface PromotionStrategy {void doPromotion();}class FanXianPromotionStrategy implements PromotionStrategy{@Overridepublic void doPromotion() {System.out.println("返现促销");}}class LiJianPromotionStrategy implements PromotionStrategy {@Overridepublic void doPromotion() {System.out.println("⽴减促销");}}class ManJianPromotionStrategy implements PromotionStrategy{@Overridepublic void doPromotion() {System.out.println("满减促销");}}class PromotionActivity {private PromotionStrategy promotionStrategy;public PromotionActivity(PromotionStrategy promotionStrategy) {this.promotionStrategy = promotionStrategy;}public void executePromotionStrategy(){promotionStrategy.doPromotion();}}public class Test {public static void main(String[] args) {PromotionActivity promotionActivity618 = new PromotionActivity(new LiJianPromotionStrategy());PromotionActivity promotionActivity1111 = new PromotionActivity(new FanXianPromotionStrategy());promotionActivity618.executePromotionStrategy();promotionActivity1111.executePromotionStrategy();}}四、策略模式的应⽤场景 策略模式在很多地⽅⽤到，如 Java SE 中的容器布局管理就是⼀个典型的实例，Java SE 中的每个容器都存在多种布局供⽤户选择。
设计模式之策略模式与模板模式
PPT文档演模板
设计模式之策略模式与模板模式
定义和角色 结构示意图
实例说明 优缺点和环境
区别与联系
缺点 （1）每个不同的实现都需要定义一个 子类，这会导致类的个数的增加，也会增 加很多具体方法的数量，使设计更加抽象。 （2）如果选用的实现方式不当，复用 情况会很差。
PPT文档演模板
设计模式之策略模式与模板模式
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
PPT文档演模板
设计模式之策略模式与模板模式
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
写个客户端来测试运行一下，示例代码如下：
PPT文档演模板
设计模式之策略模式与模板模式
目录
Contents
PPT文档演模板
1 定义和角色 2 结构示意图 3 示例代码 4 实例说明 5 优缺点和环境
设计模式之策略模式与模板模式
定义和角色 结构示意图
实例说明 优缺点和环境
区别与联系
PPT文档演模板
创建一个咖啡类(Coffee)和茶(Tea)类,都继承Beverage 抽象类，而各个方法的具体实现方式都不同
这就实现了模板方法中最重要的 类的继承和方法的复用
设计模式之策略模式与模板模式
定义和角色 结构示意图
PPT文档演模板
设计模式之策略模式与模板模式
定义和角色 结构示意图
实例说明 优缺点和环境
区别与联系
方法（两种）：
模板方法：
一个模板方法是定义在抽象类中的，把基本操作方法组合 在一起形成一个总算法或一个总行为的方法。一个抽象类可以 有任意多个模板方法，而不限于一个。每一个模板方法都可以 调用任意多个具体方法。
策略模式课件
w 算法的实现和使用算法的对象紧紧耦合在一起，使新增 算法或修改算法变得十分困难，系统应对变化的能力很 差。
第3页，共15页。
3.1 问题描述
方法
w 依据面向对象的思想，我们所能想到的办法就是将每 种算法的实现都剥离出来构成一个个独立的算法对象， 再从这些算法对象中抽象出公共的算法接口，最后将 算法接口组合到使用算法的类中。上述思路就引入了 一个新的设计模式－策略模式。
第4页，共15页。
3.2 典型案例
超市打折收银软件
为提高超市收益，超市开展促销活动。除了正常收费方式
外，添加对某些产品打折收费和满额返现收费方式。例如：
商品打8折、打7折、满300元消费返回100元、满500返 200……。实现能够计算总收费额度的功能。
如何添加和修改各 式各样的多种收费
方式?
第5页，共15页。
public CashRebate(double _discount)
{ discount = _discount;
}
public override double AcceptCash(double cash) {
return cash * discount; }
}
第8页，共15页。
3.2 典型案例
{ int nPoint = 101; double w = ((Panel)sender).Width - 1; double h = ((Panel)sender).Height - 1;
Point[] points = new Point[nPoint]; for (int i = 0; i < nPoint; i++)
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录
Contents
1 定义和角色 2 结构示意图 3 示例代码 4 实例说明 5 优缺点和环境
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
Context
-strategy:Strategy <create>
+Context(aSteategy:Strategy) +contextInterface():void
/** *上下文对象，通常会持有一个具体的策略对象 */
public class Context{ /** *持有一个具体的策略对象 */
private Strategy strategy;
/**
*构造方法，传入一个具体的策略对象
*@param aStrategy 具体的策略对象
*/
public Context(Strategy aStrategy){
return goodsPrice * (1 - 0.1);
}
}
这种解决方案存在的问题：价格类包含了
//其余人员报原价 return goodsPrice; }
所有计算报价的算法，使得价格类，尤其 是报价这个方法比较庞杂，难以维护。
this.strategy = aStrategy;
}
例如上文提到A,B,C
/**
三个对象
*上下文对客户端的操作接口，可以有参数和返回值
*/
public void contextInterface(){
//通常会转调具体的策略对象进行算法计算
strategy.algorithmInterface();
public void algorithmInterface(); }
调用具体的算法
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
2、策略实现：在具体的算法实现中，定义了三个，分别 是ConcreteStrategyA、ConcreteStrategyB、 ConcreteStrategyC，示例非常简单，由于没有具体算法 的实现，三者也就是名称不同，示例代码如下：
}else if(customerType.equals("老客户")){
System.out.println("对于老客户，统一折扣 5%");
return goodsPrice * (1 - 0.05);
}else if(customerType.equals("大客户")){
System.out.println("对于大客户，统一折扣 10%");
为了演示的简洁性，假定现在需要实现一个简化的报价 管理，实现如下的功能：
1）对普通客户或者是新客户报全价 2）对老客户报的价格，统一折扣5% 3）对大客户报的价格，统一折扣10% 该怎么实现呢？
设计模式之策略模式课件(PPT45页)
设计模式之策略模式课件(PPT45页)
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
/** *实现具体的算法 */
public class ConcreteStrategyA implements Strategy{ /** *具体的算法实现 */
public void algorithmInterface(); }
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
3、上下文的实现：示例代码如下
定义和角色 结构示意图
示例代码 实例说明
角色（三种）：
策略接口：用来约束一系列具体的策略算法。 策略实现：就是具体的算法实现。 上下文：负责和具体的策略类交互，通常上下文会持有一 个真正的策略实现。还可以让具体的策略类来获取上下文的数 据，甚至让具体的策略类来获取上下文的数据。
优缺点和环境
角色之间的关系：上下文使用策略接口来调用具体的策略 实现定义的算法。
<interface> Strategy
+algorithmInterface():void
ContreteStrategyA +algorithmInterface():void
ContreteStrategyB +algorithmInterface():void
ContreteStrategyC +algorithmInterface():void
设计模式之策略模式课件(PPT45页)
1、不用模式的解决方案：
/** *价格管理，主要完成向客户所报价格的功能 */
public class Price{
/** *报价对不同类型的客户计算不同的价格 *@param goodsPrice 商品销售原价 *@param customerType 客户类型 *@return 计算出的应该给客户报的价格
}
}
目录
Contents
1 定义和角色 2 结构示意图 3 示例代码 4 实例说明 5 优缺点和环境
设计模式之策略模式课件(PPT45页)
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
实例：报价管理问题
向客户报价，对于销售部门的人来讲，这是一个非常重 大、非常复杂的问题，对不同的客户要报不同的价格，例如 有新客户、老客户、大客户等。
设计模式之策略模式
主讲人 ：成 玉 丹 时 间：2016.11.14
目录
Contents
1 定义和角色 2 结构示意图 3 示例代码 4 实例说明 5 优缺点环境
定义和角色 结构示意图
示例代码 实例说明 优缺点和环境
定义：
策略模式定义了一系列的算法，并将每一个 算法封装起来，而且使它们还可以互相替换。策 略模式让算法独立于使用它的客户而独立变化。
策略实现（算法实现）
目录
Contents
1 定义和角色 2 结构示意图 3 示例代码 4 实例说明 5 优缺点和环境
定义和角色 结构示意图
示例的接口：
/** *策略：定义算法的接口 */
public interface Strategy{ /** *某个算法的接口，可以有传入参数，也可以有返回值 */
*/
定义了计算价格 的算法
public double quote(double goodsPrice, String customerType){
if(customerType.equals("普通客户")){
System.out.println("对于普通客户或者是新客户，没有折扣");
return goodsPrice;