Strategy 策略设计模式

我们一共六次实验，课上讲了这么多设计模式，最让我印象深刻的就是策略设计模式了，你要问我原因。一个是策略模式用的多另一个是这个模式不好学啊，看了好多博客想了半天才整明白啊。这必须写一篇博客啊！

首先Strategy是为了可复用而设计的设计模式，在具体分类中它属于行为模式，可以理解为根据不同的行为来具体分类，但是虽说行为不同，但是他们也是有共同的特点。举个例子：用拳头打和用巴掌打不一样，但是总结起来都是打，我们可以创建一个打的接口，用拳头打和用巴掌打都是这个接口的具体实现类。这样用户使用的时候对接口操作就可以了。我们可以将这种思想总结为下图。

其中Strategy接口就是我们所说的“打”这个动作，他下面的两个实现类A和B就是用巴掌大和用拳头打。但是我们不禁观察到一个问题，这个Context是干啥的啊。这个我认为就是一个封装接口的类，把接口孤零零的放在外面好像是不太美观，我们就通过Context类将他包装一下，Context类里面的操作都是通过委派这个接口来执行的，我们想要获得不同的策略只需要给这个Context类传入不同的实现类即可。

我们看一下在代码中的具体表现吧

package applicition;

public interface OUTStrategy {
    public void write(String string);
    public void close();
}

这个是我的策略接口。我在这次要实现的动作是写，所以里面有两个方法，write——用于写字符串，close——用于关闭流

package applicition;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class OUTWriter implements OUTStrategy{
	FileWriter fw;
      public OUTWriter(File file){
    	  try {
			fw=new FileWriter(file);
		} catch (IOException e) {
			System.out.println("file not find");
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
      }

	@Override
	public void write(String string) {
		// TODO Auto-generated method stub
		try {
			fw.write(string);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		try {
			fw.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package applicition;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OUTStream implements OUTStrategy{
	FileOutputStream fos;
	 public OUTStream(File file) {
		try {
			fos=new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			System.out.println("file not find");
			e.printStackTrace();
		}
	}

	@Override
	public void write(String string) {
		// TODO Auto-generated method stub
		byte b[]=string.getBytes();
		try {
			fos.write(b);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

package applicition;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class OUTBuffer implements OUTStrategy{
	FileChannel outChannel;
	ByteBuffer byteBuffer1=ByteBuffer.allocate(1024);
	 public OUTBuffer(File file) {
		 try {
			FileOutputStream fos=new FileOutputStream(file);
			outChannel=fos.getChannel();
		} catch (FileNotFoundException e) {
			System.out.println("file not find");
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}

	@Override
	public void write(String string) {
		// TODO Auto-generated method stub
		byteBuffer1.put(string.getBytes());
		byteBuffer1.flip();
		while (byteBuffer1.hasRemaining()) {
			try {
				outChannel.write(byteBuffer1);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		byteBuffer1.clear();
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		try {
			outChannel.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

我们可以看到这是我对“写入”这个操作的三个具体实现类（集体操作都是通过委派实现的），他们都实现了刚才的OUTStrategy接口，并且每一个都根据自己这个方法的特点对方法进行了重写，到现在我们就已经有三个具体的策略了，按照策略模式的要求我们只需要再创建一个Context类就可以了

package applicition;

public class OUTContext {
	//AF：这个类是策略的环境类
      OUTStrategy outStrategy;
      public OUTContext(OUTStrategy outStrategy){
    	  this.outStrategy=outStrategy;
      }
      public void write(String string){
    	  this.outStrategy.write(string);
      }
      public void close(){
    	  this.outStrategy.close();
      }
}

这个就是我们设计出来的环境类，我们可以看到这个类是通过委派接口来实现他的操作的，并且在构造函数中需要传入一个OUTStrategy接口或者是它的实现类。这样Context的write和close操作就与传入类中的OUTStrategy接口得子类的操作是一样的了。

我们在使用它的时候，直接声明一个Context类，通过用户的不同输入来给Context类传入不同的参数即可，这样我们就能够只使用一个变量而获得多种行为模式了。

    OUTContext fWriter;
		     System.out.println("chose output strategy 1. Stream 2.Writer 3.Channel");
		     Scanner in2=new Scanner(System.in);
		     String stringg2=in.nextLine();
		     if(stringg2.equals("1")){
		    	 fWriter=new OUTContext(new OUTStream(file));
		     }
		     else if(stringg2.equals("2")){
		    	 fWriter=new OUTContext(new OUTWriter(file));
		     }else {
				fWriter=new OUTContext(new OUTBuffer(file));
			}