Java中的常用设计模式

一、概念：

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的代码设计经验的总结，是一种用于固定场合的固定套路

基本分类：

  • 创建型模式：单例设计模式，工厂方法模式，抽象工厂模式
  • 结构性模式：装饰器模式，代理模式
  • 行为型模式：模板设计模式

二、设计模式详解：

  • 单例设计模式：懒汉式，饿汉式。懒汉式需要对多线程进行同步处理
  • 饿汉式：（立即加载）使用类的时候就创建实例
public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static、final修饰
    private static final Singleton instance = new Singleton();

    // 构造方法私有化
    private Singleton() {}

    // 静态方法返回该实例
    public static Singleton getInstance() {
        return instance;
    }
}

优点：实现起来简单，没有多线程同步问题。
缺点：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

  • 懒汉式：（延迟加载）当调用get方法时，再创建实例
public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：实现起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间，当getInstance方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存。
缺点：存在线程安全问题

  • 线程安全的懒汉式：
public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例，加synchronized关键字实现同步
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：在多线程的情况下，使用synchronized方法保证线程安全
缺点：效率低下

  • 最优懒汉式：
public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        // 第一次检查instance是否被实例化出来，如果没有进入if块
        if(instance == null) {
            synchronized (Singleton.class) {
                // 某个线程取得了类锁，实例化对象前第二次检查instance是否已经被实例化出来，如果没有，才最终实例出对象
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

  • 普通工厂模式：建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建


    普通工厂模式类图
/**
 * 发送邮件类
 */
public class MailSender implements Sender{
    @Override
    public void send() {
        System.out.println("正在发送邮件...");
    }
}

/**
 * 发送短信类
 */
public class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("正在发送短信...");
    }
}

/**
 * 工厂类
 */
public class SendFactory {

    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }
}

/**
 * 测试类
 */
public class SendFactoryTest {

    public static void main(String[] args) {

        // 1. 声明工厂类型的引用指向工厂类型的对象
        SendFactory sf = new SendFactory();
        // 2. 调用生产方法来实现对象的创建
        Sender sender = sf.produce("mail");
        // 3. 使用对象调用方法模拟发生的行为
        sender.send();
    }
}

主要缺点：在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并可能出现空指针异常
优点：在创建大量对象的前提下，扩展性和可维护性强

  • 多个工厂模式：


    多个工厂模式类图
/**
 * 工厂类
 */
public class SendFactory {

    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }
    // 自定义对应的成员方法创建对应的对象
    public Sender produceMail() {
        return new MailSender();
    }

    public Sender produceSms() {
        return new SmsSender();
    }
}

/**
 * 测试类
 */
public class SendFactoryTest {

    public static void main(String[] args) {

        // 1. 声明工厂类型的引用指向工厂类型的对象
        SendFactory sf = new SendFactory();
        // 2. 调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        Sender sender = sf.produceMail();
        // 3. 使用对象调用方法模拟发生的行为
        sender.send();
    }
}

主要缺点：在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法

  • 静态工厂模式：


    静态工厂模式类图
/**
 * 工厂类
 */
public class SendFactory {

    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }

    // 自定义对应的静态成员方法创建对应的对象
    public static Sender produceMail() {
        return new MailSender();
    }

    public static Sender produceSms() {
        return new SmsSender();
    }
}

/**
 * 测试类
 */
public class SendFactoryTest {

    public static void main(String[] args) {

        // 1. 声明工厂类型的引用指向工厂类型的对象
        //SendFactory sf = new SendFactory();
        // 2. 调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produceMail();
        Sender sender = SendFactory.produceMail();
        // 3. 使用对象调用方法模拟发生的行为
        sender.send();
    }
}

实际意义：适合于出现了大量的产品需要创建且它们具有共同的接口时，可以通过工厂方法模式进行创建
主要缺点：工厂方法模式有一个问题就是，类的创建依赖工厂类，如果想要拓展程序生产新的产品，就必须对工厂的代码进行修改，就违背了开闭原则

  • 抽象工厂模式：


    抽象工厂模式类图
/**
 * 工厂接口类
 */
public interface Provider {

    // 自定义抽象方法描述产品的生产行为
    Sender produce();
}

/**
 * 发送邮件的工厂类
 */
public class MailSendFactory implements Provider{
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

/**
 * 发送短信的工厂类
 */
public class SmsSendFactory implements Provider{
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

/**
 * 测试类
 */
public class SendFactoryTest {

    public static void main(String[] args) {

        Provider provider = new MailSendFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}

优点：当需要生产新的产品时，只需要创建对应的工厂类即可

  • 装饰器模式：给一个对象动态地增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例


    装饰器模式类图
/**
 * 定义接口
 */
public interface Sourceable {

    // 自定义抽象方法
    void method();
}

/**
 * 定义原本的类
 */
public class Source implements Sourceable{
    @Override
    public void method() {
        System.out.println("原本的类！");
    }
}

/**
 * 装饰类
 */
public class Decorator implements Sourceable{

    private Sourceable source;

    public Decorator(Sourceable source) {
        this.source = source;
    }

    @Override
    public void method() {
        // 保证原有功能
        source.method();

        // 添加新的功能
        System.out.println("我是装饰器！");
    }
}

/**
 * 测试类
 */
public class SourceableTest {

    public static void main(String[] args) {

        // 使用原有类实现功能
        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("------------------------------");

        // 使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();
    }
}
输出结果

实际意义：

  • 可以实现一个类功能的扩展
  • 可以动态地增加功能，而且还能动态撤销

缺点：产生过多相似的对象，不易排错

  • 代理模式：找一个代理类，替原对象进行一些操作


    代理模式类图
/**
 * 代理类
 */
public class Proxy implements Sourceable{

    private Source source;

    public Proxy() {
        source = new Source();
    }
    @Override
    public void method() {
        source.method();
        System.out.println("我是代理模式！");
    }
}

/**
 * 测试类
 */
public class SourceableTest {

    public static void main(String[] args) {

        // 使用原有类实现功能
        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("------------------------------");
        
        // 使用代理类实现功能
        Sourceable sourceable1 = new Proxy();
        sourceable1.method();
    }
}

实际意义：

  • 如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制
  • 使用代理模式，可以将功能划分得更加清晰，有助于后期维护

与装饰器模式的比较：

  • 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象

  • 装饰器模式关注于在一个对象上动态的添加方法，而代理模式关注于控制对对象的访问

  • 模板模式：指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果


    模板模式类图
/**
 * 定义一个抽象类
 */
public abstract class AbstractCalculator {

    // 自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果

    public int splitExpression(String exp, String op) {
        String[] sArr = exp.split(op);
        return calculate(Integer.parseInt(sArr[0]), Integer.parseInt(sArr[1]));
    }
    // 自定义抽象方法实现运算
    public abstract int calculate(int ia, int ib);
}

/**
 * 定义加法
 */
public class Plus extends AbstractCalculator{
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

/**
 * 定义减法
 */
public class Minus extends AbstractCalculator{
    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

/**
 * 测试类
 */
public class AbstractCalculatorTest {

    public static void main(String[] args) {

        AbstractCalculator abstractCalculator = new Plus();
        int res = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的运算结果是：" + res);
    }
}
输出

实际意义：

  • 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用
  • 不同的子类实现不同的效果形成多态，有助于后期维护
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,542评论 6赞 504
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,822评论 3赞 394
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 163,912评论 0赞 354
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,449评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,500评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,370评论 1赞 302
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,193评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,074评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,505评论 1赞 314
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,722评论 3赞 335
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,841评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,569评论 5赞 345
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,168评论 3赞 328
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,783评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,918评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,962评论 2赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,781评论 2赞 354