软件构造心得体会：设计模式期末总结
本学期的学习就这样结束了，在本学期的学习课程中，最重要的，也是对我们编程生涯最重要的，就是各种设计模式的运用，有的面向可复用的有的面向可维护的，下面对部分实现较为麻烦的进行简单总结。
目录
可维护
State Pattern
对于某一个类，如果它具有某种属性，那么我们以前可能会通过各种ifelse语句来进行判断。但是这样非常不利于我们今后扩展新状态，所以我们利用形式语言与自动机的思想，做了这样一个基于状态的设计模式，将类中管理一个state，将其委派给其他类管理。
class Context {
State state; //保存对象的状态
//设置初始状态
public Context(State s) {state = s;}
//接收外部输入，开启状态转换
public void move(char c) { state = state.move(c); }
//判断是否达到合法的最终状态
public boolean accept() { return state.accept(); }
public State getState() { return this.state; }
}
下面是我的状态接口及其实现，其中accept函数用来确定其是否达到最终状态
//状态接口
public interface State {
State move(char c);
boolean accept();
}
class State1 implements State {
static State1 instance = new State1(); //singleton模式 (see 8-3)
private State1() {}
public State move (char c) {
switch (c) {
case 'a': return State2.instance; //返回新状态的singleton实 例
case 'b': return State1.instance;
default: throw new IllegalArgumentException();
} }
public boolean accept() {
return false;
} //该状态非可接受状态
} Memento Pattern
与状态模式相关联的，还有一个备忘录模式，对于之前的状态模式，我们可能会存在需要回滚到它的某个历史状态的情况，这就是我们的备忘录模式。
下面用Menento管理一个历史状态
class Memento {
private State state;
public Memento(State state) {
this.state = state;
}
public State getState() {
return state;
}
}原来需要管理状态的ADT增加一个方法
public void restore(Memento m) {
state = m.getState();
System.out.println("Originator: State after restoring from Memento: " + state);
}然后用一个类管理一个历史状态列表，并管理去除管状态的方法
class Caretaker {
private List<Memento> mementos
= new ArrayList<>();
public void addMemento(Memento m) {
mementos.add(m);
}
public Memento getMemento() {
return mementos.get(?);
}
}Visitor
本方法为ADT预留一个将来可扩展功能的“接入点”，外部实现的功能代码可以在不改变ADT本身的情况下通过delegation接入ADT
下面举一个我实现例子，只简略实现必要接口
public interface element{
public void accept(avistor visitor);
}
public Aelement implements element{
private final String x= "x"
public void accept(avistor visitor)
{
visitor.visit(this);
}
public String getx()
{
return x;
}
}上面是我的ADT
public interface avisitor{
public void accept(avistor visitor);
}
public avisitorimpl implements element{
private final String = "x"
public void visit(Aelement a)
{
System.out.println(a.getx);
}
}上面是我的游客ADT，若是想要增加新的功能，只需要增加新的实现即可。
客户端
avisitor w=new avisitorimpl（）;
element a=new Aelement();
a.accept(w);Factory Method pattern
工厂方法模式，就是创建实例时用来隐藏具体类，把实例化这一过程放在方法中实现，我们常常使用静态方法实现下面例子：
public interface animalFactory {
static public animal creatduck(){
return Duck；
};
static public animal creatcow(){
return cow；
};
}Abstract Factory
对于普通的工厂方法，我们同过静态方法隐式地返回一个实例，而抽象工厂方法，则是返回具有多个属性的一种搭配，帮助客户进行搭配。
可复用
Strategy模式
该模式有多种不同的算法来实现同一个任务，但需要client根据需要动态切换算法，而不是写死在代码里，为不同的实现算法构造抽象接口，利用delegation，运行时动态传入client倾向的算法类实例。
public interface actor()
{
public void act();
}
public class act1 implements actor()
{
public String act(){
return "act1";
}
}
public class act2 implements actor()
{
public String act(){
return "act2";
}
}
上面是我实现act操作所实现的两个不同的类
然后构造ADT
public interface at()
{
public void act();
}
public class AT1 implements at()
{
public void act(actor x){
x.act
}
}客户端通过调用不同的构造不同类型的实例对象来做这件事
AT OP=new at；
actor m1=new act1（）；
actor m2=new act2（）；
OP.act（m1）；
OP.act（m2）；Decorator
为对象增加不同侧面的特性，对每一个特性构造子类，通过委派机制增加到对象上
首先实现一个最顶层的接口
interface Stack {
void push(Item e);
Item pop();
}然后实现最基本的功能
public class ArrayStack implements Stack {
... //rep
public ArrayStack() {...}
public void push(Item e) {
...
}
public Item pop() {
...
}
...
}然后创建一个抽象实例类
public abstract class StackDecorator implements Stack {
protected final Stack stack;
public StackDecorator(Stack stack) {
this.stack = stack;
}
public void push(Item e) {
stack.push(e);
}
public Item pop() {
return stack.pop();
}
...在构造函数内将其委派给其他stack，注意他的每个子类都是stack类型，为最顶层的接口
若想要增加新的功能，则构造一个实例类继承抽象类，并将其特性加入方法中
public class UndoStack extends StackDecorator implements Stack {
private final UndoLog log = new UndoLog();
public UndoStack(Stack stack) {
super(stack);
}
public void push(Item e) {
log.append(UndoLog.PUSH, e);
super.push(e);
}
public void undo() {
//implement decorator behaviors on stack
}
...
}具体客户端操作时
Stack t = new SecureStack(new SynchronizedStack(new UndoStack(s));客户端需要一个具有多种特性的object，通过一层一层的就像一层一 装饰来实现，就像穿衣服
Iterator
客户端希望遍历被放入容器/集合类的一组ADT对象，无需关心容器的具体类型也就是说，不管对象被放进哪里，都应该提供同样的遍历方式
Iterable接口：实现该接口的集合对象是可迭代遍历的
public interface Iterable<T> {
...
Iterator<T> iterator();
}下面给出Iterator实现。
**private class PairIterator implements Iterator<E> {
private boolean seenFirst = false, seenSecond = false;
public boolean hasNext() { return !seenSecond; }
public E next() {
if (!seenFirst) { seenFirst = true; return first; }
if (!seenSecond) { seenSecond = true; return second; }
throw new NoSuchElementException();
}
public void remove() {
throw new UnsupportedOperationException();
} } }**上一篇： 软件设计模式
下一篇： JavaWeb三大组件之Filter