设计模式基础

一、设计模式简介

设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

总结：简单地说设计模式就是一些常用编码规范的总结，是一种思想，如果你是大牛，也可以自己写一种设计模式供大家使用

二、设计模式四大要素

模式名称 ：以一个恰当的词来描述模式的问题、解决方案和效果。

问题 ：描述应该在何时使用设计模式。

解决方案 ：提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象）来解决这个问题。

效果：描述设计模式应用的效果及使用设计模式应该权衡的问题。

三、设计模式六大原则（武功秘籍，懂了秘籍自己就可以根据秘籍去创造自己的设计模式，不必拘泥于23中设计模式）

1. 开闭原则

开放封闭有两个含义，一个是对于拓展是开放的，另一个是对于修改是关闭的。在软件的生命周期内，因为变化、升级和维护等原因需要对软件原有代码进行修改时，可能会给旧代码中引入错误，也可能会使我们不得不对整个功能进行重构，并且需要原有代码经过重新测试。

解决方案： 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

总结：

面向对象设计/编程 终极目标（实现开闭原则）
一个是对于拓展是开放的，另一个是对于修改是关闭的
尽量不要修改已有代码

2. 单一职责原则

通俗讲就是我们不要让一个类承担过多的职责。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到破坏。

解决方案： 分别建立两个类C1、C2，使类C1完成职责A，C2完成职责B。这样，当修改类C1时，不会使职责B发生故障风险；同理，当修改类C2时，也不会使职责A发生故障风险。

总结：

不要让一个类承担过多的职责

3. 里氏替换原则

里氏代换原则告诉我们，在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常。

解决方案： 当使用继承时，遵循里氏替换原则。类B继承类A时，除添加新的方法完成新增功能外，尽量不要重写父类A的方法，也尽量不要重载父类A的方法。

总结：

继承父类后，尽量不要重写或者重载父类的方法。

4. 依赖倒转原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。 类A直接依赖类B，假如要将类A改为依赖类C，则必须通过修改类A的代码来达成。这种场景下，类A一般是高层模块，负责复杂的业务逻辑；类B和类C是低层模块，负责基本的原子操作；假如修改类A，会给程序带来不必要的风险。

解决方案： 将类A修改为依赖接口I，类B和类C各自实现接口I，类A通过接口I间接与类B或者类C发生联系，则会大大降低修改类A的几率。

总结：

通过抽象或者接口来实现类与类之间的依赖关系。

5. 接口隔离原则

建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少。也就是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

解决方案： 将臃肿的接口拆分为独立的几个接口，实现类分别与他们需要的接口建立依赖关系。

总结：

建立单一接口，不要建立庞大/臃肿的接口

6. 迪米特法则

迪米特法则也称为最少知道原则，一个实体应该尽可能少的与另外一个实体发生相互作用（依赖关系）。 

解决方案： 尽可能降低类之间的耦合

总结：

只提供方法给外部调用，不要让外部知道你是怎么做的

四、设计模式分类

创建型设计模式：

创建型模式抽象实例化过程，在什么对象被创建、谁创建它、它是怎么被创建的以及何时创建这些方面给予你很大的灵活性——主要处理对象的创建，实例化对象。

结构型设计模式：

结构型模式涉及到如何组合类和对象以获得更大的结构，采用继承机制来组合接口或实现——处理类或对象的组合以获得更庞大的功能。

行为型设计模式：

行为模式涉及到算法和对象间职责的分配，不仅描述对象或类的模式，还描述它们之间的通信模式——处理对象之间的交互

五、常用的六种设计模式（招式，设计模式六大原则的实现）

1. 创建型模式之【单例模式】

问题 对于某些场景，确保一个类只有一个实例对象是很重要的，并且这个实例是易于被访问的。

解决方案：将实例化操作隐藏在一个类中，由这个类来保证实例的创建和唯一性。

单例模式 饿汉(一开始就创建实例)

package com.study.demo1;
/**
 * 
 * @author lgs
 * @redame 单例模式 饿汉(一开始就创建实例)
 */
public class SingletonObjectA {
    private static SingletonObjectA instance = new SingletonObjectA();
    
    private SingletonObjectA(){}
    
    public static SingletonObjectA getInstance(){
        return instance;
    }
}

单例模式 饱汉(需要的时候才创建实例)

package com.study.demo1;
/**
 * 
 * @author lgs
 * @redame 单例模式 饱汉(需要的时候才创建实例)
 */
public class SingletonObjectB {
    private static volatile SingletonObjectB instance = null;
    
    private SingletonObjectB(){}
    
    public static SingletonObjectB getInstance(){
        if(instance==null){
            synchronized(instance){
                if(instance == null){
                    instance = new SingletonObjectB();
                }
            }
        }
        return instance;
    }
}

主程序入口：

public class Demo1 {
    public static void main(String[] args) {
        SingletonObjectA object1 = SingletonObjectA.getInstance();
        
        SingletonObjectA object2 = SingletonObjectA.getInstance();
        
        System.out.println(object1);
        System.out.println(object2);
    }
}

2. 创建型模式之【工厂模式】

问题：当一个类无法确定要创建哪种类的对象，或者需要通过子类来确定具体对象的创建时。

解决方案：创建一个创建对象的工厂，工厂在程序执行过程中具体决定创建哪个对象。

发送消息的接口：

package com.study.demo2;
/**
 * 
 * @author lgs
 * 
 */
public interface Sender {

    public void send();
}

使用邮件发送消息：

package com.study.demo2;
/**
 * 
 * @author lgs
 * 
 */
public class MailSender implements Sender {

    @Override
    public void send() {
        System.out.println("Use the email sender message.");
    }

}

使用SMS发送消息：

package com.study.demo2;
/**
 * 
 * @author lgs
 * 
 */
public class SmsSender implements Sender {

    @Override
    public void send() {
        System.out.println("Use the SMS sender messages.");
    }

}

使用微信发送消息：

package com.study.demo2;
/**
 * 
 * @author lgs
 * 
 */
public class WechatSender implements Sender {

    @Override
    public void send() {
        System.out.println("Use the Wechat sender messages.");
    }

}

普通工厂模式：

package com.study.demo2;
/**
 * 
 * @author lgs
 * @redame 普通工厂模式
 */
public class MessageFactoryA {
    public static String MAIL="MAIL";
    public static String SMS="SMS";
    public static String WE_CHAT="WE_CHAT";
    
    public Sender product(String type){
        if(MessageFactoryA.MAIL.equals(type)){
            return new MailSender();
        } else if(MessageFactoryA.SMS.equals(type)){
            return new SmsSender();
        } else if(MessageFactoryA.WE_CHAT.equals(type)){
            return new WechatSender();
        }
        return null;
    }
}

工厂方法模式：

package com.study.demo2;
/**
 * 
 * @author lgs
 * @redame 工厂方法模式
 */
public class MessageFactoryB {

    public Sender productMail(){
        return new MailSender();
    }
    public Sender productSMS(){
        return new SmsSender();
    }
    public Sender productWechat(){
        return new WechatSender();
    }
}

主程序入口：

package com.study.demo2;

/**
 * 
 * @author lgs
 */
public class Demo2 {
    public static void main(String[] args) {
        // 普通工厂模式
        // MessageFactoryA factory = new MessageFactoryA();
        // Sender sender = factory.product(MessageFactoryA.WE_CHAT);
        // sender.send();
        // 工厂方法模式
        MessageFactoryB factory = new MessageFactoryB();
        Sender sender = null;
        if (MessageFactoryA.WE_CHAT.equals("1")) {
            sender = factory.productWechat();
        }

    }
}

3. 结构型模式之【适配器模式】

问题：

有时，为复用而设计的工具箱类不能够被复用的原因，仅仅是因为它的接口与专业应用领域所需要的接口不匹配。

解决方案：

应用通过适配器调用接口，由适配器使得工具箱类可以被使用。

总结：把不同的功能集成到适配器。类似通过转换器把香港iPhone的充电器插头和大陆的iPhone的充电器插头一起使用

3.1 类适配器模式：

package com.study.demo3.classType;
/**
 * 
 * @author lgs
 * 
 */
public class Source {

    public void method1(){
        System.out.println("一个普通方法实现.");
    }
}

package com.study.demo3.classType;
/**
 * 
 * @author lgs
 * 
 */
public interface Targetable {

    //与原类中的方法相同
    public void method1();
    
    //新类中的方法
    public void method2();
}

 

package com.study.demo3.classType;
/**
 * 
 * @author lgs
 * @类适配器模式:通过继承Source类,Targetable接口的实现类拥有了Source的方法.
 */
public class SpecialAdapter extends Source implements Targetable {

    @Override
    public void method2() {
        System.out.println("这是一个特殊方法实现.");
    }

}

主程序入口：

public class Demo31 {

    public static void main(String[] args) {
        Targetable target = new SpecialAdapter();
        target.method1();
        target.method2();
    }
}

3.2 对象适配器模式：

package com.study.demo3.objectType;
/**
 * 
 * @author lgs
 * 
 */
public class Source {

    public void method1(){
        System.out.println("一个普通方法实现.");
    }
}

 

package com.study.demo3.objectType;
/**
 * 
 * @author lgs
 * 
 */
public interface Targetable {

    //与原类中的方法相同
    public void method1();
    
    //新类中的方法
    public void method2();
}

 

package com.study.demo3.objectType;
/**
 * 
 * @author lgs
 * @对象适配器模式
 */
public class SpecialAdapter implements Targetable {

    /**
     * 可匹配Source的子类 
     **/
    private Source source;
    public SpecialAdapter(Source source){
        super();
        this.source = source;
    }
    @Override
    public void method1() {
        source.method1();
    }

    @Override
    public void method2() {
        System.out.println("这是一个特殊方法实现.");
    }

}

 

主程序入口：

public class Demo32 {
    public static void main(String[] args) {
        
        Targetable adapter = new SpecialAdapter(new Source());
        adapter.method1();
        adapter.method2();
    }
}

 

4. 结构型模式之【代理模式】

问题:

对象的访问需要被控制，不允许其他对象任意访问此对象接口。

解决方案:

代理类开放接口提供访问，所有访问由代理类决定具体的调用。

总结：

类似于经纪人和艺人的关系，艺人的任何事情都要先经过经纪人的许可才能去做

package com.study.demo4;
/**
 * 
 * @author lgs
 * 
 */
public abstract class AbstractObject {

    //代理方法
    public abstract void operation();
}

 

package com.study.demo4;
/**
 * 
 * @author lgs
 * @真正做事的人
 * 
 */
public class RealObject extends AbstractObject {

    @Override
    public void operation() {
        System.out.println("具体执行任务.");
    }

}

package com.study.demo4;
/**
 * 
 * @author lgs
 * @代理人
 * 
 */
public class ProxyObject extends AbstractObject {

    RealObject realObject = new RealObject();
    @Override
    public void operation() {
        System.out.println("执行任务前, 做一些什么事情.");
        realObject.operation();
        
    }

}

 

主程序入口：

public class Demo4 {
    public static void main(String[] args) {
        AbstractObject obj = new ProxyObject();
        obj.operation();
    }
}

5. 行为模式之【观察者模式】

问题：

将一个系统分割成一系列相互协作的类有一个常见的副作用：需要维护相关对象间的一致性，然而维护对象间的一致性可能导致各类之间的紧密耦合，这样将降低它们的可重用性。

解决方案：

观察者模式建立一个目标和任意个依赖它的观察者，一旦目标状态发生改变，所有的观察者都得到通知。

package com.study.demo5;
/**
 * 
 * @author lgs
 * 
 */
public interface Observer {
    public void update();
}

package com.study.demo5;
/**
 * 
 * @author lgs
 * 
 */
public class ObserverA implements Observer {

    @Override
    public void update() {
        System.out.println("观察者A观察到对象的变化.");
    }

}

package com.study.demo5;
/**
 * 
 * @author lgs
 * 
 */
public class ObserverB implements Observer {

    @Override
    public void update() {
        System.out.println("观察者B观察到对象的变化.");
    }

}

package com.study.demo5;
/**
 * 
 * @author lgs
 * 
 */
public interface Subject {
    //本身的任务调用
    public void operation();
    
}

package com.study.demo5;

import java.util.Vector;

/**
 * 
 * @author lgs
 * 
 */
public abstract class AbstractSubject implements Subject {

    private Vector<Observer> observerList = new Vector<Observer>();
    
    public void add(Observer observer) {
        observerList.add(observer);
    }

    public void del(Observer observer) {
        observerList.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}

 

package com.study.demo5;
/**
 * 
 * @author lgs
 * 
 */
public class MySubject extends AbstractSubject {

    @Override
    public void operation() {
        System.out.println("执行方法, 状态修改. ");
        //通知所有观察者
        notifyObservers();
    }

}

 

主程序入口：

public class Demo5 {
    public static void main(String[] args) {
        AbstractSubject subject = new MySubject();
        subject.add(new ObserverA());
        subject.add(new ObserverB());
        subject.operation();
    }
}

 

6. 行为模式之【策略模式】

问题：

开发中常见的情况：实现某功能可以有多种算法或者策略，可根据实际情况选择不同的算法或策略来完成该功能。如果将所有算法或策略都封装在一个类中，提供不同方法来实现，这个类就变得臃肿，而且新增算法或策略时，需要修改封装算法类的源码。

解决方案：

使用不同类来封装不同的算法

package com.study.demo6;
/**
 * 
 * @author lgs
 * 
 */
public interface MemberStrategy {
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double calcPrice(double booksPrice);
}

package com.study.demo6;
/**
 * 
 * @author lgs 6  * 
 */
public class AdvancedMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        System.out.println("高级会员8折");
        return booksPrice * 0.8;
    }

}

package com.study.demo6;
/**
 * 
 * @author lgs 6  * 
 */
public class IntermediateMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        System.out.println("中级会员9折");
        return booksPrice * 0.9;
    }

}

package com.study.demo6;
/**
 * 
 * @author lgs 6  * 
 */
public class PrimaryMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        System.out.println("初级会员没有折扣");
        return booksPrice;
    }

}

 

package com.study.demo6;
/**
 * 
 * @author lgs
 * 
 */
public class Price {
    //持有一个具体的策略对象
    private MemberStrategy strategy;

    /**
     * @param strategy
     */
    public Price(MemberStrategy strategy) {
        super();
        this.strategy = strategy;
    }
    
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double quote(double booksPrice){
        return this.strategy.calcPrice(booksPrice);
    }
}

 

主程序入口：

package com.study.demo6;
/**
 * 
 * @author lgs
 * 
 */
public class Demo6 {
    public static void main(String[] args) {
        //选择并创建需要使用的策略对象
        MemberStrategy strategy = new AdvancedMemberStrategy();
        //创建环境
        Price price = new Price(strategy);
        //计算价格
        double quote = price.quote(300);
        System.out.println("图书的最终价格为：" + quote);
    }
}