设计模式 策略模式

我认为主要是实现了一个私有的接口属性在主要执行的类中，
例如：

public interface Eat{ 
 
 //定义一个接口，然后用接口的实现类来完成方法的重写
public void dothings(); 
}

interface Eat的一个实现类

public class pizza implements Eat { 
public void dothings() { 
 System.out.println("拨打披萨店的电话，购买一块好吃的披萨"); 
 } 
} 

interface Eat的第二个实现类

public class noodles implements Eat{ 
public void dothings() { 
 System.out.println("拨打面条店的电话，购买一碗好吃的重庆小面"); 
 } 
} 

interface Eat的第三个实现类

public class vegetables implements Eat{ 
public void dothings() { 
 System.out.println("拨打沙拉的电话，购买一份有营养的蔬菜沙拉"); 
 } 
} 

这三个实现类，都是为了在主要类完成功能的时候。

public class Context { 
	//构造函数，你要准备什么样的食物
	private Eat eat; 
	public Context(Eat eat){ 
		 this.eat = eat; 
	 } 
 
	//开始吃饭了
	public void dothings(){ 
		 this.eat.dothings(); 
	 } 
} 

这里用到的是接口的实现，接口的实现用的是实现类来实例化的，但是接受的对象类型，可以是接口

你想准备什么食物的话，就在构造函数Context中去写什么类型的实现类

public class xiaoming { 
/**
 * 小明
 */
	public static void main(String[] args) { 
	       Context context; 
	        
	 //刚刚早饭
	 System.out.println("-----------刚刚到早饭-------------"); 
	 context = new Context(new vegetables ()); //拨打沙拉的电话
	 context.dothings(); //拆开执行
	 System.out.println("\n\n\n\n\n\n\n\n"); 
	 
	 //中午
	 System.out.println("-----------中午了-------------"); 
	 context = new Context(new noodles ()); 
	 context.dothings(); //拨打面条店的电话
	 System.out.println("\n\n\n\n\n\n\n\n"); 
	 
	 //
	 System.out.println("-----------晚上了
	-------------"); 
	 context = new Context(new pizza()); 
	 context.dothings(); //拨打pizza店的电话
	 System.out.println("\n\n\n\n\n\n\n\n"); 
	 
	 /*
	*
	 * 策略模式的好处就是：体现了高内聚低耦合的特性呀，缺点嘛，这个那个，我回去再查查
	 */
	 } 
} 
这就是策略模式，高内聚低耦合的特点也表现出来了，
还有一个就是扩展性，也就是 OCP 原则，策略类可以继续增加下去，只要修改 Context.java 就可以了，这
个不多说了，自己领会