总结设计模式—(大话设计模式中篇)
public interface Human {
public void say();
}
class Man implements Human {
public void say() {
System.out.println("男人");
}
}
class Woman implements Human {
public void say() {
System.out.println("女人");
}
}
1、装饰模式： 动态的为对象添加额外的逻辑，且不需要生成额外的子类。
abstract class Decorator implements Human {
protected Human human;
public void setHuman(Human human) {
this.human = human;
}
public void say() {
human.say();
}
public static void main(String[] args) {
Man man = new Man();
ManDecoratorA md1 = new ManDecoratorA();
ManDecoratorB md2 = new ManDecoratorB();
//对man包装
md1.setHuman(man);
//md2包装 md1,扩展包装
md2.setHuman(md1);
md2.say();
}
}
class ManDecoratorA extends Decorator {
public void say() {
//一定要调用父类
super.say();
reSay();
System.out.println("DecoratorA类");
}
public void reSay() {
System.out.println("重复说");
}
}
class ManDecoratorB extends Decorator {
public void say() {
super.say();
System.out.println("===============");
System.out.println("DecoratorB类");
}
}
上面代码输出
装饰类继承与同一类 Human，通过装饰类A添加新逻辑，装饰类B对A进行包装。
装饰模式主要用于对类的简化，去除类中多余或者说让类只关注与核心职责
2、观察者模式 ： 让多个观察者监视一个同一对象，对象状态改变，会通知观察者们。
从代码角度，上面装饰者模式是多个装饰者，数量少可以手动添加。如果是装饰者多呢，我们一步一步添加装饰类 就非常麻烦了。
所以 我们在 类似装饰者模式的工厂中添加一个list集合对一群装饰者进行逻辑。
//所有的观察者都监视该类
class Subject {
private List<Observer> observers = new ArrayList<Observer>();
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObservers();
}
public void attach(Observer observer){
observers.add(observer);
}
//遍历
public void notifyAllObservers(){
for (Observer observer : observers) {
observer.update();
}
}
}
抽象观察者：
abstract class Observer { protected Subject subject; public abstract void update(); }
观察者们 二进制 与十进制
class BinaryObserver extends Observer{ public BinaryObserver(Subject subject){ this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); } } class OctalObserver extends Observer{ public OctalObserver(Subject subject){ this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); } }
客户端 运行
public static void main(String[] args) { Subject subject = new Subject(); new OctalObserver(subject); new BinaryObserver(subject); System.out.println("First state change: 15"); subject.setState(15); System.out.println("Second state change: 10"); subject.setState(10); }
运行结果：
3、状态模式
因为工作业务中，有些逻辑是比较复杂且累赘。我们用的swich或者if用的太多，明显看的不舒服，每次修改逻辑需要更改现有逻辑。Java面向对象开发，是为了将一些代码进行分解，分割，强调的是抽象统一行为，面对需求我们只需要增加新模块，不是更改原有代码。我们可以用状态模式来解决。
这里放的代码有点长，请用电脑看 会舒服些，点击看状态模式
4、单一职责原则 类单一职责，一个类只因某一个变化才发生变化。换句角度，Java代码强调低耦合，一个类变化，避免其他类发生改变。
5、开放-封闭原则 面对新需求，我们可以对原有类进行扩展也就是 extends或者implement。而不是对原有类进行修改，可以新增。所以，我们需要频繁变化的部分做抽象或者 接口。
6、依赖倒转原则(里氏代换原则) 子类型可以替换父类 举例： FatherClass fatherClass = new ChildrenClass(); fatherClass.method(); 这里变向来说就是多态。
7、迪米特原则 两个没有关联的类需要进行属性上的赋值，可以通过第三个类进行关联。举例来说，Java中MVC架构中，m层中，controller业务需要 其他controller层协作，我们可以拿到service层进行业务重合，而不是向controller层添加别的controller。
8、适配器模式 因为不同的两个接口需要适配放在一起，因为Java的单继承性，所以我们可以将某个类耦合进来。简单来说和代理模式有点类似。只是代理模式的的方法相当于是被重写了一遍。而适配模式可以使用不同接口的方法；
interface Animal{ public void exist(); }
适配Human和Animal代码:
class HumanAnimal implements Animal{ Human human; HumanAnimal(Human human){ this.human = human; } public void exist(){ human.say(); } }
客户端示例：
public static void main(String[] args) { Human human = new Human() { public void say() { System.out.println("人要自然的和谐相处"); } }; Animal animal=new HumanAnimal(human); // 实现适配 animal.exist(); }
9、 备忘录模式 不同的类都耦合一个代表一个属性，这个属性也在备忘录中，然后通过备忘录类传递之前保存的值；
public class MementoPattern { public static void main(String[] args) { Originator originator = new Originator(); originator.state = "On"; originator.show(); Caretaker caretaker = new Caretaker(); caretaker.setMemento( originator.createMemento() ); originator.state = "Off"; originator.show(); originator.setMemento(caretaker.getMemento()); originator.show(); } } //发起人 class Originator{ public String state; public Memento createMemento(){ return new Memento(state); } public void setMemento(Memento memento){ state = memento.getState(); } public void show(){ System.out.println( "state = " + state ); } } //备忘录 class Memento{ public String state; public Memento(String state) { this.state = state; } public String getState() { return state; } } //管理者 class Caretaker{ public Memento memento; public Memento getMemento() { return memento; } public void setMemento(Memento memento) { this.memento = memento; } }
运行结果：
10、组合模式 应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多及目录呈现等树形结构数据的操作。是一种结构型模式
abstract class ComponentA { protected String name; public ComponentA(String name) { this.name = name; } public abstract void Add(ComponentA c); public abstract void Remove(ComponentA c); public abstract void Display(int depth); } class Leaf extends ComponentA { public Leaf(String name) { super(name); } public void Add(ComponentA c) { System.out.println("Can not add to a leaf"); } public void Remove(ComponentA c) { System.out.println("Can not remove from a leaf"); } public void Display(int depth) { String temp = ""; for (int i = 0; i < depth; i++) temp += '-'; System.out.println(temp + name); } } class Composite extends ComponentA { private List<ComponentA> children = new ArrayList<ComponentA>(); public Composite(String name) { super(name); } public void Add(ComponentA c) { children.add(c); } public void Remove(ComponentA c) { children.remove(c); } //递归 public void Display(int depth) { String temp = ""; for (int i = 0; i < depth; i++) temp += '-'; System.out.println(temp + name); for (ComponentA c : children) { c.Display(depth + 2); } } }
public static void main(String[] args) { Composite root = new Composite("root"); root.Add(new Leaf("Leaf A")); root.Add(new Leaf("Leaf B")); Composite compX = new Composite("Composite X"); compX.Add(new Leaf("Leaf XA")); compX.Add(new Leaf("Leaf XB")); root.Add(compX); Composite compXY = new Composite("Composite XY"); compXY.Add(new Leaf("Leaf XYA")); compXY.Add(new Leaf("Leaf XYB")); compX.Add(compXY); root.Display(1); }
中篇设计模式比上篇复杂点，主要是关于两个不同类之类之间的关联。
比方说用类耦合，类集合耦合，关联性比较大。
