常见的设计模式笔记（简单工厂模式、单例模式）

最新推荐文章于 2022-12-07 18:40:38 发布

程序猿小泽

最新推荐文章于 2022-12-07 18:40:38 发布

阅读量259

点赞数

分类专栏： Java 文章标签：设计模式

原文链接：https://www.jianshu.com/p/e55fbddc071c

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

原文链接：https://www.jianshu.com/p/e55fbddc071c

设计模式笔记

简单工厂模式

优点
- 将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，实现了解耦；
- 把初始化实例时的工作放到工厂里进行，使代码更容易维护。更符合面向对象的原则 & 面向接口编程，而不是面向实现编程。
缺点
- 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响；
- 违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
- 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

实例步骤：

创建抽象产品类 & 定义具体产品的公共接口；

abstract class Product {
    public abstract void Show();
}

创建具体产品类（继承抽象产品类） & 定义生产的具体产品；

class  ProductA extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

class  ProductC extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

创建工厂类，通过创建静态方法根据传入不同参数从而创建不同具体产品类的实例；

public class Factory {
    public static Product Manufacture(String ProductName){
//工厂类里用switch语句控制生产哪种商品；
//使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();

            case "B":
                return new ProductB();

            case "C":
                return new ProductC();

            default:
                return null;

        }
    }

}

外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例

public class SimpleFactoryPattern {
    public static void main(String[] args) {
        //客户要产品A
        try {
            //调用工厂类的静态方法 & 传入不同参数从而创建产品实例
            Factory.Manufacture("A").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品B
        try {
            Factory.Manufacture("B").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品C
        try {
            Factory.Manufacture("C").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品D
        try {
            Factory.Manufacture("D").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }
    }
}

结果输出：

生产出了产品A
生产出了产品C
生产出了产品C
没有这一类产品

单例模式

实例引入
背景：小成有一个塑料生产厂，但里面只有一个仓库。
目的：想用代码来实现仓库的管理
现有做法：建立仓库类和工人类
其中，仓库类里的quantity=商品数量；工人类里有搬运方法MoveIn(int i)和MoveOut(int i)。

出现的问题：通过测试发现，每次工人搬运操作都会新建一个仓库，就是货物都不是放在同一仓库，这是怎么回事呢？（看下面代码）

//仓库类
class StoreHouse {
    private int quantity = 100;

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public int getQuantity() {
        return quantity;
    }
}

//搬货工人类
class Carrier{
    public StoreHouse mStoreHouse;
    public Carrier(StoreHouse storeHouse){
        mStoreHouse = storeHouse;
    }
    //搬货进仓库
    public void MoveIn(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);
    }
    //搬货出仓库
    public void MoveOut(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);
    }
}

//工人搬运测试
public class SinglePattern {
    public static void main(String[] args){
        StoreHouse mStoreHouse1 = new StoreHouse();
        StoreHouse mStoreHouse2 = new StoreHouse();
        Carrier Carrier1 = new Carrier(mStoreHouse1);
        Carrier Carrier2 = new Carrier(mStoreHouse2);

        System.out.println("两个是不是同一个？");

        if(mStoreHouse1.equals(mStoreHouse2)){
            System.out.println("是同一个");
        }else {
            System.out.println("不是同一个");
        }
        //搬运工搬完货物之后出来汇报仓库商品数量
        Carrier1.MoveIn(30);
        System.out.println("仓库商品余量："+
        	Carrier1.mStoreHouse.getQuantity());
        Carrier2.MoveOut(50);
        System.out.println("仓库商品余量："+
        	Carrier2.mStoreHouse.getQuantity());
    }
}

结果：

两个是不是同一个？
不是同一个
仓库商品余量：130
仓库商品余量：50

单例模式介绍

模式说明
实现1个类只有1个实例化对象 & 提供一个全局访问点
作用（解决的问题）
保证1个类只有1个对象，降低对象之间的耦合度
从上面可看出：工人类操作的明显不是同一个仓库实例，而全部工人希望操作的是同一个仓库实例，即只有1个实例
工作原理
在Java中，我们通过使用对象（类实例化后）来操作这些类，类实例化是通过它的构造方法进行的，要是想实现一个类只有一个实例化对象，就要对类的构造方法下功夫：

单例模式的一般实现：（含使用步骤）

public class Singleton {
//1. 创建私有变量 ourInstance（用以记录 Singleton 的唯一实例）
//2. 内部进行实例化
    private static Singleton ourInstance  = new  Singleton();

//3. 把类的构造方法私有化，不让外部调用构造方法实例化
    private Singleton() {
    }
//4. 定义公有方法提供该类的全局唯一访问点
//5. 外部通过调用getInstance()方法来返回唯一的实例
    public static  Singleton newInstance() {
        return ourInstance;
    }
}

好了，单例模式的介绍和原理应该了解了吧？那么我们现在来解决上面小成出现的“仓库不是一个”的问题吧！

实例讲解

改善上面例子的代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//单例仓库类
class StoreHouse {

    //仓库商品数量
    private int quantity = 100;
    //自己在内部实例化
    private static StoreHouse ourInstance  = new StoreHouse();;
    //让外部通过调用getInstance()方法来返回唯一的实例。
    public static StoreHouse getInstance() {
        return ourInstance;
    }

    //封闭构造函数
    private StoreHouse() {
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public int getQuantity() {
        return quantity;
    }
}


//搬货工人类
class Carrier{
    public StoreHouse mStoreHouse;
    public Carrier(StoreHouse storeHouse){
        mStoreHouse = storeHouse;
    }
    //搬货进仓库
    public void MoveIn(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);
    }
    //搬货出仓库
    public void MoveOut(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);
    }
}

//工人搬运测试
public class SinglePattern {
    public static void main(String[] args){
        StoreHouse mStoreHouse1 = StoreHouse.getInstance();
        StoreHouse mStoreHouse2 = StoreHouse.getInstance();
        Carrier Carrier1 = new Carrier(mStoreHouse1);
        Carrier Carrier2 = new Carrier(mStoreHouse2);

        System.out.println("两个是不是同一个？");

        if(mStoreHouse1.equals(mStoreHouse2)){
            System.out.println("是同一个");
        }else {
            System.out.println("不是同一个");
        }
        //搬运工搬完货物之后出来汇报仓库商品数量
        Carrier1.MoveIn(30);
        System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity());
        Carrier2.MoveOut(50);
        System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity());
    }
}

结果：

两个是不是同一个？
是同一个
仓库商品余量：130
仓库商品余量：80

从结果分析，使用了单例模式后，仓库类就只有一个仓库实例了，再也不用担心搬运工人进错仓库了！！！

特点

优点
提供了对唯一实例的受控访问；
由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能；
可以根据实际情况需要，在单例模式的基础上扩展做出双例模式，多例模式；
缺点
单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”。
如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。

单例模式的实现方式

饿汉式: 初始化单例类时即创建单例

具体实现

class Singleton {

    // 1. 加载该类时，单例就会自动被创建
    private static  Singleton ourInstance  = new  Singleton();
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
    // 3. 通过调用静态方法获得创建的单例
    public static  Singleton newInstance() {
        return ourInstance;
    }
}

应用场景: 除了初始化单例类时即创建单例外，继续延伸出来的是：单例对象要求初始化速度快 & 占用内存小

懒汉式:按需、延迟创建单例

具体实现

class Singleton {
    // 1. 类加载时，先不自动创建单例
   //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
    // 3. 需要时才手动调用 newInstance（） 创建 单例   
    public static  Singleton newInstance() {
    // 先判断单例是否为空，以避免重复创建
    if( ourInstance == null){
        ourInstance = new Singleton();
        }
        return ourInstance;
    }
}

缺点基础实现的懒汉式是线程不安全的
下面，将对懒汉式进行优化，使得适合在多线程环境下运行

同步锁（懒汉式的改进）

原理
使用同步锁 synchronized锁住创建单例的方法，防止多个线程同时调用，从而避免造成单例被多次创建
即，getInstance（）方法块只能运行在1个线程中
若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则会被阻塞而一直等待
而在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下单例对象的唯一性
具体实现

// 写法1
class Singleton {
    // 1. 类加载时，先不自动创建单例
    //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
// 3. 加入同步锁
public static synchronized Singleton getInstance(){
        // 先判断单例是否为空，以避免重复创建
        if ( ourInstance == null )
            ourInstance = new Singleton();
        return ourInstance;
    }
}

// 写法2
// 该写法的作用与上述写法作用相同，只是写法有所区别
class Singleton{ 

    private static Singleton instance = null;

    private Singleton(){
}

    public static Singleton getInstance(){
        // 加入同步锁
        synchronized(Singleton.class) {
            if (instance == null)
                instance = new Singleton();
        }
        return instance;
    }
}

缺点
每次访问都要进行线程同步（即调用synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）
实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步

双重校验锁（懒汉式的改进）

原理
在同步锁的基础上，添加1层 if判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能

具体实现

class Singleton {
    private static  Singleton ourInstance  = null；

    private Singleton() {
    }
    
    public static  Singleton newInstance() {
     // 加入双重校验锁
    // 校验锁1：第1个if
    if( ourInstance == null){  // ①
     synchronized (Singleton.class){ // ②
      // 校验锁2：第2个 if
      if( ourInstance == null){
          ourInstance = new Singleton();
          }
      }
  }
        return ourInstance;
   }
}


// 说明
// 校验锁1：第1个if
// 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作
// 即直接跳到执行 return ourInstance

// 校验锁2：第2个 if 
// 作用：防止多次创建单例问题
// 原理
  // 1. 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()
  // 2. 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕
  // 3. 当线程A释放同步锁时，单例已创建，即instance已非空
  // 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例

缺点
实现复杂 = 多种判断，易出错

静态内部类

原理
根据静态内部类的特性，同时解决了按需加载、线程安全的问题，同时实现简洁
在静态内部类里创建单例，在装载该内部类时才会去创建单例
线程安全：类是由 JVM加载，而JVM只会加载1遍，保证只有1个单例
具体实现

class Singleton {
    
    // 1. 创建静态内部类
    private static class Singleton2 {
       // 在静态内部类里创建单例
      private static  Singleton ourInstance  = new Singleton()；
    }

    // 私有构造函数
    private Singleton() {
    }
    
    // 延迟加载、按需创建
    public static  Singleton newInstance() {
        return Singleton2.ourInstance;
    }

}

调用过程说明：
1. 外部调用类的newInstance()
2. 自动调用Singleton2.ourInstance

此时单例类Singleton2得到初始化
而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；
由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性
最终只创建1个单例

程序猿小泽

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
常见的设计模式笔记（简单工厂模式、单例模式）

原文链接：https://www.jianshu.com/p/e55fbddc071c设计模式笔记简单工厂模式优点将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，实现了解耦；把初始化实例时的工作放到工厂里进行，使代码更容易维护。更符合面向对象的原则 & 面向接口编程，而不是面向实现编程。缺点工厂类集中了所有实例（产品）的创建逻辑，一旦这个工...
复制链接

扫一扫