关于几种常见的复用可维护设计模式

设计模式原则

SOILD
SRP：单一职责
OCP：开闭原则
ISP：接口隔离原则
LSP：历史替换原则
DIP：依赖倒置原则

不同设计模式大致实现：

工厂模式
interface Afactory
{
public A factory();
}
class concreteAfactory
{
public A factory()
{
return new A1();
}
}
class concreteAfactory
{
public A factory()
{
return new A2();
}
}

抽象工厂模式
代理模式
interface A
{
public void XXX();
}
class realA1 implements A
{
public void XXX()
{
}
}
class ProxyA2 implements A
{
private realA1 r;
public void XXX()
{
r.void();
}
}
观察者模式
interface observer
{
public void update();
}
interface subject
{
public void attach(Observer a);
public void detach();
public void notify();
public void setstate();
public State getstate();
}
class conobserver implements observer
{
private Subject subject;
private State state;
conobserver(Subject subject)
{
this.subject = subject;
subject.attch(this);
}
public void update()
{
this.state = subject.getstate();
}
{
}
class consubject implements subject
{
private List l = new ArrayList();
public void attach(Observer a)
{
l.add(a);
}
public void detach(Observer a)
{
l.remove(a);
}
public void notify()
{
for(Observer a:l)
{
a.update();
}
}
public void setstate(State state)
{
this.state = state;
}
public State getstate()
{
return this.state;
}
}
访问者模式
class element
{
public int accept(Visitor v)
{
return v.visit(this);
}
}
interface Visitor
{
public int visit(element a);
}
class conVisitor implements Visitor
{

public int visit(element a)
{
a.xxx()
xxxx
return xxxx;
}

}
状态模式
interface State
{
public State move(String string);
}
class fuck implements State
{
public State move(String string)
{
return new pregnant();
}
}
class ADT
{
private State s;
public void move(String string)
{
s = s.move(string);
}
public boolean accpect()
{
}
}