Java设计模式系列3-----装饰模式,策略模式,观察者模式

1.装饰模式

装饰(Decorator)模式又叫做包装模式.通过一种对客户端透明的方式来扩展对象的功能,是继承关系的一个替换方案.

package com.ibeifeng.news;

public interface Car {
	
	public void show();
	
	public void run();
}
package com.ibeifeng.news;

public abstract class CarDecorator implements Car{
	private Car car;
	
	public Car getCar() {
		return car;
	}

	public void setCar(Car car) {
		this.car = car;
	}

	public CarDecorator(Car car) {
		this.car = car;
	}
	
	public abstract void show();
}
package com.ibeifeng.news;

public class FlyCarDecorator extends CarDecorator{

	public FlyCarDecorator(Car car) {
		super(car);
	}

	public void show() {
		this.getCar().show();
		this.fly();
	}
	
	public void fly() {
		System.out.println("可以飞");
	}

	public void run() {
		
	}
}
package com.ibeifeng.news;

public class SwimCarDecorator extends CarDecorator {

	public SwimCarDecorator(Car car) {
		super(car);
	}

	public void show() {
		this.getCar().show();
		this.swim();
	}
	
	public void swim() {
		System.out.println("可以游");
	}

	public void run() {
		
	}

}
package com.ibeifeng.news;

public class MainClass {
	public static void main(String[] args) {
		Car car = new RunCar();
		
		car.show();
		System.out.println("---------");
		
		Car swimcar = new SwimCarDecorator(car);
		swimcar.show();
		System.out.println("---------");
		
		Car flySwimCar = new FlyCarDecorator(swimcar);
		flySwimCar.show();
	}
}

装饰模式的角色和职责
抽象组件角色:一个抽象接口,是被装饰类和装饰类的父接口.Car
具体组件角色:为抽象组件的实现类. RunCar
抽象装饰角色:包含一个组件的引用,并定义了与抽象组件一致的接口.CarDecorator
具体装饰角色:为抽象装饰角色的实现类.负责具体的装饰.FlyCarDecorator,FlyCarDecorator

3.策略模式

Strategy模式也叫策略模式是行为模式之一,它对一系列的算法加以封装,为所有算法定义一个抽象的算法接口,并通过继承该抽象算法接口对所有的算法加以封装和实现,具体的算法选择交由客户端决定(策略).Strategy模式主要用来平滑地处理算法的切换.

package com.ibeifeng.strategy;

public interface Strategy {

	public double cost(double num);
}
package com.ibeifeng.strategy;

public class StrategyA implements Strategy{

	public double cost(double num) {
		return num * 0.8;
	}

}
package com.ibeifeng.strategy;

public class StrategyB implements Strategy {

	public double cost(double num) {
		if(num >= 200) {
			return num - 50;
		}
		return num;
	}

}
package com.ibeifeng.strategy;

public class Context {
	private Strategy strategy;
	
	public Context(Strategy strategy) {
		this.strategy = strategy;
	}
	
	public double cost(double num){
		return this.strategy.cost(num);
	}
	
}
package com.ibeifeng.strategy;

public class MainClass {
	public static void main(String[] args) {
		double num = 200;
		Context context = new Context(new StrategyB());
		double newNum = context.cost(num);
		System.out.println("实际付账" + newNum + "元");
	}
}

策略模式的角色和职责
Strategy:策略(算法)抽象.
ConcreteStrategy:各种策略(算法)的具体实现.
Context:策略的外部封装类,或者说策略的容器类.根据不同策略执行不同的行为.策略由外部环境决定.
策略模式的优点
1.策略模式提供了管理相关算法族的办法.策略类的等级结构定义了一个算法或行为族.恰当使用继承可以把公共的代码移到父类里面,从而避免重复的代码.
2.策略模式提供了可以替换继承关系的办法.继承可以处理多种算法或行为.如果不是用策略模式,那么使用算法或行为的环境类就可能会有一些子类,每一个子类提供一个不同的算法或行为.但是,这样一来算法或行为的使用者就和算法或行为本身混在一起.决定使用哪一种算法或采取哪一种行为的逻辑和算法或行为的逻辑混合在一起.从而不可能在独立演化,继承使得动态改变算法或行为变得不可能.
3.使用策略模式可以避免使用多重条件转移语句.多重转移语句不易维护,它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起,统统列在一个多重转移语句里面,比使用继承的办法还要原始和落后.
策略模式的缺点
1.客户端必须知道所有的策略类,并自行决定使用哪一个策略类.这就意味着客户端必须理解这些算法的区别,以便适时选择恰当的算法类.换言之,策略模式只适用于客户端知道所有的算法或行为的情况.
2.策略模式造成很多的策略类.有时候可以通过把依赖于环境的状态保存到客户端里面,而将策略类设计成可共享的,这样策略类实例可以被不同的客户端使用.换言之,可以使用享元模式来减少对象的数量.

3.观察者模式

Observer模式是行为模式之一,它的作用是当一个对象的状态发生变化时,能够自动通知其他关联对象,自动刷新对象状态.
Observer模式提供给关联对象一种同步通信的手段,使某个对象与依赖它的其他对象之间保持状态同步.
观察者模式的角色和职责
Subject(被观察者):被观察的对象.当需要被观察的状态发生变化时,需要通知队列中所有的观察者对象.Subject需要维持(添加,删除,通知)一个观察者对象的队列列表.
ConcreteSubject:被观察者的具体实现.包含一些基本的属性状态及其他操作.
Observer(观察者):接口或抽象类.当Subject的状态发生变化时,Observer对象将通过一个callback函数得到通知.
ConcreteBoserver:观察者的具体实现.得到通知后将完成一些具体的业务逻辑处理.

package com.ibeifeng.news;

public class Article {
	private String articleTitle;
	private String articleContent;

	public String getArticleTitle() {
		return articleTitle;
	}

	public void setArticleTitle(String articleTitle) {
		this.articleTitle = articleTitle;
	}

	public String getArticleContent() {
		return articleContent;
	}

	public void setArticleContent(String articleContent) {
		this.articleContent = articleContent;
	}

}
package com.ibeifeng.news;

import java.util.Observable;
/*
*被观察者继承Observale
*/
public class BlogUser extends Observable {
	
	public void publishBlog(String articleTitle,String articleContent) {
		Article art = new Article();
		art.setArticleTitle(articleTitle);
		art.setArticleContent(articleContent);
		System.out.println("博主:发表新文章，文章标题:" + articleTitle + ",文章内容:" + articleContent);
		this.setChanged();
		this.notifyObservers(art);
	}
}
package com.ibeifeng.news;

import java.util.Observable;
import java.util.Observer;
/*
*观察者实现Observer
*/
public class MyObServer implements Observer {

	public void update(Observable o, Object arg) {
		Article art = (Article)arg;
		
		System.out.println("博主发表了新的文章，快去看吧!");
		System.out.println("博客标题为：" + art.getArticleTitle());
		System.out.println("博客内容为:" + art.getArticleContent());
	}

}
package com.ibeifeng.news;
//测试
public class MainClass {
	public static void main(String[] args) {
		BlogUser user = new BlogUser();
		//注册观察者
		user.addObserver(new MyObServer());
		user.publishBlog("哈哈，博客上线了", "大家多来访问");
	}
}

观察者模式的典型应用
/- 侦听事件驱动程序设计中的外部事件
/-侦听/监视某个对象的状态变化
/-发布者/订阅者(publisher/subscriber)模型中,当一个外部事件(新的产品,消息的出现等等)被触发时,通知邮件列表中的订阅者.