我们一共六次实验,课上讲了这么多设计模式,最让我印象深刻的就是策略设计模式了,你要问我原因。一个是策略模式用的多另一个是这个模式不好学啊,看了好多博客想了半天才整明白啊。这必须写一篇博客啊!
首先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));
}