java 学习笔记【六】设计模式

一、策略模式

1.把会变化和经常会变化的的代码分离（大多数模式着眼于变化）

2.针对接口编程而非针对实现。

3.封装行为，把每组行为想象成一族算法（类）

4.多用组合，少用继承（方便运行时动态改变行为）

如用接口 IFlyBehavior和FlyWithWings、FlyNoWay实现类来分离出可变功能Fly。

Duck类中有display，swim方法不变，而用接口 IFlyBehavior， IQuackBehavior来实现

使得可以实现动态改变方法行为，动态改变方法执行的内容

如（委托模式，委托IFlyBehavior,IQuackBehavior来处理fly和quack动作）

public class Duck{
display();
IFlyBehavior flyBehavior;//fly接口和quack接口
IQuackBehavior quackBehavior;
flyPerform(){ flyBehavior.fly();}
quackPerform(){  quackBehavior.fly();}
setFlyPerform(FlyBehavior fb){//设置fly接口对象
flyBehavior=fb;
}
}
public interface IFlyBehavior{//接口
public void fly();
}
interface IQuackBehavior
{public quack();
}
public class FlyWithWings implements IFlyBehavior{//用翅膀飞类
fly(){system.out.println("fly wing!!");}
}
public class FlyWithRocket implements IFlyBehavior{//用火箭飞的类
fly(){
system.out.println("fly with rocket!");
}
}
//实现：
public class ModelDuck(){
public ModelDuck(){
flyBehavior=new FlyWithRocket();}
}
public void static main (string[] args){
Duck o=new ModelDuck();
o.performFly();//输出用翅膀飞
o.setFlyPerform(new FlyWithRocket());//可以
o.performFly();//输出用火箭飞
}

二、观察者模式：（通常适用于api或远程webservice）

1.为了交互对象的送耦合而努力

 如设置一个提供给多方的天气信息api：主题只需要知道观察者实现了一个IObserver接口，其他的不考虑

interface ISubject{//提供者接口
registerObserver();//注册观察者
removeObserver();//移除
notifyObserver();//通知
getState();
setState();
}
interface IObserver{//观察者
update
}

三、装饰者模式

装饰者和被装饰者要有相同的类型。因此都继承自同一个接口或者抽象类。装饰者的行为是由组件componentt组合而来。

//饮料基类
public abstract class Beverage{
String description="unknow";
public String getDescription( ) {return description;}
public abstruct double cost();
}
//调料装饰者
public abstract class CondimentDecorate extends Beverage{
public String abstruct getDescription();
}
//一种浓咖啡
public class Espresso extends Beverage{
public Espresso(){
description="Espresso";
}
//返回价格。注意return
public double cost(){
return 1.99;
}
}
//摩卡，一种巧克力调料
public class Mocha extends CondimentDecorate{
Beverage bever;
public Mocha (Beverage beverage){
this.bever=beverage;
}
public String getDescription(){
return bever.getDescription+ " ,mocha";
}
public Double cost(){
return 0.2+bever.cost();
}
}

四、工厂模式

使用creatObject()之类的来批量制造对象。（重在解耦decoupling）

如：Creator抽象类，它实现了操纵所有产品的方法，而把factoryMethod抽象给子类ConcreteCreator（实在的）来实现。只有他才能知道如何制造产品。

而所有的产品ConcreteProduct必须实现Product共同接口，

1依赖倒置原则：要依赖抽象，不要依赖具体类

2几大原则（尽量遵守）变量不要拥有具体类的引用；不要让类派生自具体类；不要覆盖基类中的方法

3，有相同类似功能的就抽象出接口（方便自动匹配方法）如抽象工厂接口，实现：NY工厂，chicago工厂

4当明确需要向上转型时才用继承。组合是has a。类应该是对扩展开放，对修改关闭。组合关系的缺点：过多的类。继承的缺点：臃肿，难于修改。

下面的例子中，由NYPizzaStore中的 ingredientFactory.creatPizza(type);来用工厂创造pizza，NYPizzaStore只需继承pizzaStore抽象类中的orderPizza来实现订餐