总结设计模式—(大话设计模式中篇)

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);

    }

 　　中篇设计模式比上篇复杂点，主要是关于两个不同类之类之间的关联。

　　　　比方说用类耦合，类集合耦合，关联性比较大。