浅谈几种设计模式：

(一) 策略模式（Strategy）

对不用算法封装，为所有算法提供抽象接口，并通过继承该抽象算法接口对所有算法加以封装实现，具体算法选择交由客户端决定，即决策过程由客户端决定。

//策略接口  Strategy

(一) 策略模式（Strategy）
对不用算法封装，为所有算法提供抽象接口，并通过继承该抽象算法接口对所有算法加以封装实现，具体算法选择交由客户端决定。
//策略接口  Strategy
public interface Strategy {
    public double cost(double num) ;
}
//策略算法 相当于工厂
public class Context {
	private Strategy strategy;
	public Context(Strategy s) {
		this.strategy = s;
	}
	public double cost(double num) {
	return	this.strategy.cost(num);
	}
}
//打八折策略
public class StrategyA implements Strategy{
	public double cost(double num) {	
		 return num*0.8;
	}	
}
//满两百减50策略
public class StrategyB implements Strategy{
	public double cost(double num) {
		if (num>=200) {
			return num-50;
		}
		 return num;
	}	
}
public class Test {  //测试方法
  public static void main(String[] args) {
	  double num=200;
	  Context context=new Context(new StrategyA());
	  double newNum=context.cost(num);
	  System.out.println("实际付款"+newNum);  //实际付款160.0
	  Context context2=new Context(new StrategyB());
	  double newNum2=context2.cost(num);
	  System.out.println("实际付款"+newNum2); //实际付款150.0
  }
}

(三) 观察者模式

    观察者观察到被观察者的改变

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;
	}

//省略get set方法  }
//具体被观察者 博主
public class BlogUser extends Observable {
	public void publihBlog(String articleTitle, String articleContent) {
		Article article = new Article();
		article.setArticleTitle(articleTitle);
		article.setArticleContent(articleContent);
		System.out.println("博主：发表新文章了！！文章标题：" + articleTitle + "  " + "文章内容：" + articleContent);
		this.setChanged(); // 手动表示已经改变
		this.notifyObservers(article);   //通知观察者   带上文章对象
	}
}
// 具体观察者
public class MyObserver implements Observer{
	public void update(Observable o, Object arg) {
		    System.out.println("------------");
		    Article art =(Article)arg;  //强制转换
          System.out.println("观察者收到的通知："+"博主发表新博客了，快去看看！");
	       	}
}
public class Test {   //测试方法
         public static void main(String[] args) {
        	    BlogUser blogUser=new BlogUser();  //被观察者
blogUser.addObserver(new MyObserver());  //添加观察者	
			blogUser.publihBlog("AOP详解", "这是满满地的干货");
		}
}

运行结果：

博主：发表新文章了！！文章标题：AOP详解  文章内容：这是满满地的干货

观察者收到的通知：博主发表新博客了，快去看看！

博客标题：AOP详解  博客内容：这是满满地的干货

（三）装饰者模式  （在Java的IO中运用到了此模式）

      用于解决扩展过多，可以动态将责任加到对象上，比生成子类更加灵活。比如豆浆有N多种，导致类爆炸。包括Component(被装饰者基类)，ConcreteComponent(具体被装饰对象),Decorator(装饰者抽象基类)，ConcreteDecorator(具体装饰者)。

运行结果：

实际付款160.0

实际付款150.0

//被装饰的接口（基类）
public interface Drink {
    float cost();        //计算价格
    String description();//描述
}
//具体的被装饰类   豆浆
public class SoyaBeanMilk implements Drink{
	public float cost() {// 相当于纯豆浆
		return 10f;
	}
	public String description() {
		return "纯豆浆";
	}
}
//装饰者的基类 来修饰饮品
public abstract class Decorator implements Drink {
	public Drink drink; // 要装饰的对象
	public Decorator(Drink d) {
		this.drink = d;
	}
	public float cost() {		
		return drink.cost();
	}
	public String description() {		
		return drink.description();
	}
}
//具体的装饰者类  加糖的
public class SugarDecorator extends Decorator {
	public SugarDecorator(Drink d) {
		super(d);
	}
	public float cost() {
		return super.cost()+1.0f;  //加糖之后 加1元的糖钱
	}
	public String description() {
		return super.description()+"+糖";
	}
}
//具体的装饰者类  加鸡蛋的
public class EggDecorator extends Decorator {
	public EggDecorator(Drink d) {
		super(d);
	}
	public float cost() {
		return super.cost()+3.0f;  //加鸡蛋之后 加3元的鸡蛋钱
	}
	public String description() {
		return super.description()+"+鸡蛋";
	}
}
public class Test {//测试方法
     public static void main(String[] args) {
		Drink drink=new SoyaBeanMilk();  //饮料要的是豆浆
		SugarDecorator sugar=new SugarDecorator(drink);  //加糖  1
		EggDecorator egg=new EggDecorator(sugar);     //在加糖的基础上加鸡蛋 3
		System.out.println("你点的豆浆是："+egg.description());//纯豆浆+糖+鸡蛋
		System.out.println("一共花费："+egg.cost()+"元");  //14元
     }
}