设计模式

最新推荐文章于 2024-04-09 22:14:22 发布

you猿人

最新推荐文章于 2024-04-09 22:14:22 发布

阅读量111

点赞数

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

本文链接：https://blog.csdn.net/qq_41265377/article/details/100114850

版权

java 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

设计模式

单例模式

利用单例模式的话，我们就可以实现在需要使用时才创建对象，这样就避免了不必要的资源浪费。

饿汉方式（线程安全）

“饿汉方式” 就是说JVM在加载这个类时就马上创建此唯一的单例实例，不管你用不用，先创建了再说，如果一直没有被使用，便浪费了空间，典型的空间换时间，每次调用的时候，就不需要再判断，节省了运行时间。

   public class Singleton {
           //在静态初始化器中创建单例实例，这段代码保证了线程安全
            private static Singleton uniqueInstance = new Singleton();
            //Singleton类只有一个构造方法并且是被private修饰的，所以用户无法通过new方法创建该对象实例
            private Singleton(){}
            public static Singleton getInstance(){
                return uniqueInstance;
            }
        }

懒汉方式

“ 懒汉式” 就是说单例实例在第一次被使用时构建，而不是在JVM在加载这个类时就马上创建此唯一的单例实例。

但是上面这种方式很明显是线程不安全的，如果多个线程同时访问getInstance()方法时就会出现问题。如果想要保证线程安全，一种比较常见的方式就是在getInstance() 方法前加上synchronized关键字

public class Singleton {  
      private static Singleton uniqueInstance;  
      private Singleton (){
      }   
      //没有加入synchronized关键字的版本是线程不安全的
      public static Singleton getInstance() {
          //判断当前单例是否已经存在，若存在则返回，不存在则再建立单例
	      if (uniqueInstance == null) {  
	          uniqueInstance = new Singleton();  
	      }  
	      return uniqueInstance;  
      }  
 }

懒汉方式（双重检查加锁版本）

利用双重检查加锁（double-checked locking），首先检查是否实例已经创建，如果尚未创建，“才”进行同步。这样以来，只有一次同步，这正是我们想要的效果。

 public class Singleton {
    
        //volatile保证，当uniqueInstance变量被初始化成Singleton实例时，多个线程可以正确处理uniqueInstance变量
        private volatile static Singleton uniqueInstance;
        private Singleton() {
        }
        public static Singleton getInstance() {
           //检查实例，如果不存在，就进入同步代码块
            if (uniqueInstance == null) {
                //只有第一次才彻底执行这里的代码
                synchronized(Singleton.class) {
                   //进入同步代码块后，再检查一次，如果仍是null，才创建实例
                    if (uniqueInstance == null) {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }

静态内部类实现单例模式

当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

  public class Singleton {
    	private static class SingletonHoler {
    		/**
    		 * 静态初始化器，由JVM来保证线程安全
    		 */
    		private static Singleton instance = new Singleton();
    	}
     
    	private Singleton() {
    	}
     
    	public static Singleton getInstance() {
    		return SingletonHoler.instance;
    	}
     
    }

简单工厂模式

单工厂模式又叫静态方法模式（因为工厂类定义了一个静态方法）
现实生活中，工厂是负责生产产品的；同样在设计模式中，简单工厂模式我们可以理解为负责生产对象的一个类，称为“工厂类”
模式组成
组成（角色）关系作用
抽象产品（Product）具体产品的父类描述产品的公共接口
具体产品（Concrete Product）抽象产品的子类；工厂类创建的目标类描述生产的具体产品
工厂（Creator）被外界调用根据传入不同参数从而创建不同具体产品类的实例
使用步骤
- 创建抽象产品类 & 定义具体产品的公共接口；
- 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
- 创建工厂类，通过创建静态方法根据传入不同参数从而创建不同具体产品类的实例；
- 外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例
实例
5.1 创建抽象产品类，定义具体产品的公共接口

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

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

 //具体产品类A
    class  ProductA extends  Product{
    
        @Override
        public void Show() {
            System.out.println("生产出了产品A");
        }
    }
    
    //具体产品类B
    class  ProductB extends  Product{
    
        @Override
        public void Show() {
            System.out.println("生产出了产品C");
        }
    }
    
    //具体产品类C
    class  ProductC extends  Product{
    
        @Override
        public void Show() {
            System.out.println("生产出了产品C");
        }
    }

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

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

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

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

5.5 输出结果

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

5.6 优点

将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，实现了解耦；
把初始化实例时的工作放到工厂里进行，使代码更容易维护。更符合面向对象的原则 & 面向接口编程，而不是面向实现编程。

5.7 缺点

 1. 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响；

  2. 违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。

   3. 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

5.8 应用场景

客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时；
当工厂类负责创建的对象（具体产品）比较少时

工厂方法模式

定义

工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

主要作用

将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。 

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

模式组成

组成（角色）关系作用
抽象产品（Product）具体产品的父类描述具体产品的公共接口
具体产品（Concrete Product）抽象产品的子类；工厂类创建的目标类描述生产的具体产品
抽象工厂（Creator）具体工厂的父类描述具体工厂的公共接口
具体工厂（Concrete Creator）抽象工厂的子类；被外界调用描述具体工厂；实现FactoryMethod工厂方法创建产品的实例

使用步骤

创建抽象工厂类，定义具体工厂的公共接口；
创建抽象产品类，定义具体产品的公共接口；
创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

实例
5.1 背景：小成有一间塑料加工厂（仅生产A类产品）；随着客户需求的变化，客户需要生产B类产品；
5.2 冲突：改变原有塑料加工厂的配置和变化非常困难，假设下一次客户需要再发生变化，再次改变将增大非常大的成本；
5.3 解决方案：小成决定置办塑料分厂B来生产B类产品；
实例使用步骤

6.1 创建抽象工厂类，定义具体工厂的公共接口

    abstract class Factory{
        public abstract Product Manufacture();
    }

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

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

     6.3 常见具体产品类

  //具体产品A类
       class  ProductA extends  Product{
           @Override
           public void Show() {
               System.out.println("生产出了产品A");
           }
       }
        
       //具体产品B类
       class  ProductB extends  Product{
        
           @Override
           public void Show() {
               System.out.println("生产出了产品B");
           }
       }

 6.4 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

   //工厂A类 - 生产A类产品
       class  FactoryA extends Factory{
           @Override
           public Product Manufacture() {
               return new ProductA();
           }
       }
        
       //工厂B类 - 生产B类产品
       class  FactoryB extends Factory{
           @Override
           public Product Manufacture() {
               return new ProductB();
           }
       }

6.5 外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

 //生产工作流程
       public class FactoryPattern {
           public static void main(String[] args){
               //客户要产品A
               FactoryA mFactoryA = new FactoryA();
               mFactoryA.Manufacture().Show();
        
               //客户要产品B
               FactoryB mFactoryB = new FactoryB();
               mFactoryB.Manufacture().Show();
           }
       }

结果
生产出了产品A
生产出了产品C
优点

更符合开-闭原则
新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
简单工厂模式需要修改工厂类的判断逻辑
符合单一职责原则
每个具体工厂类只负责创建对应的产品
简单工厂中的工厂类存在复杂的switch逻辑判断
不使用静态工厂方法，可以形成基于继承的等级结构。
简单工厂模式的工厂类使用静态工厂方法

总结：工厂模式可以说是简单工厂模式的进一步抽象和拓展，在保留了简单工厂的封装优点的同时，让扩展变得简单，让继承变得可行，增加了多态性的体现。
缺点

添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度；同时，有更多的类需要编译和运行，会给系统带来一些额外的开销；
由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类；
一个具体工厂只能创建一种具体产品

抽象工厂模式

一个工厂往往需要生产多类产品。为了解决上述的问题，我们又使用了一种新的设计模式：抽象工厂模式

定义
抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。

抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类

主要作用
允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦
模式组成

组成（角色）关系作用
抽象产品族（AbstractProduct）抽象产品的父类描述抽象产品的公共接口
抽象产品（Product）具体产品的父类描述具体产品的公共接口
具体产品（Concrete Product）抽象产品的子类；工厂类创建的目标类描述生产的具体产品
抽象工厂（Creator）具体工厂的父类描述具体工厂的公共接口
具体工厂（Concrete Creator）抽象工厂的子类；被外界调用描述具体工厂；实现FactoryMethod工厂方法创建产品的实例

使用步骤

创建抽象工厂类，定义具体工厂的公共接口
创建抽象产品族类，定义抽象产品的公共接口
创建抽象产品类（继承抽象产品族类），定义具体产品的公共接口
创建具体产品类（继承抽象产品类） & 定义生产的具体产品
创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法
客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

实例

背景：小成有两间塑料加工厂（A厂仅生产容器类产品；B厂仅生产模具类产品）；随着客户需求的变化，A厂所在地的客户需要也模具类产品，B厂所在地的客户也需要容器类产品；
冲突：没有资源（资金+租位）在当地分别开设多一家注塑分厂
解决方案：在原有的两家塑料厂里增设生产需求的功能，即A厂能生产容器+模具产品；B厂间能生产模具+容器产品。

实例使用步骤

5.1 创建抽象工厂类，定义具体工厂的公共接口

 abstract class Factory{
      public abstract Product ManufactureContainer();
       public abstract Product ManufactureMould();
   }

5.2 创建抽象产品族类 ，定义具体产品的公共接口


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

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

    //容器产品抽象类
       abstract class ContainerProduct extends AbstractProduct{
           @Override
           public abstract void Show();
       }
       
       //模具产品抽象类
       abstract class MouldProduct extends AbstractProduct{
           @Override
           public abstract void Show();
       }

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

   //容器产品A类
       class ContainerProductA extends ContainerProduct{
           @Override
           public void Show() {
               System.out.println("生产出了容器产品A");
           }
       }
       
       //容器产品B类
       class ContainerProductB extends ContainerProduct{
           @Override
           public void Show() {
               System.out.println("生产出了容器产品B");
           }
       }
       
       //模具产品A类
       class MouldProductA extends MouldProduct{
       
           @Override
           public void Show() {
               System.out.println("生产出了模具产品A");
           }
       }
       
       //模具产品B类
       class MouldProductB extends MouldProduct{
       
           @Override
           public void Show() {
               System.out.println("生产出了模具产品B");
           }
       }

5.5 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品是累的方法

//A厂 - 生产模具+容器产品
       class FactoryA extends Factory{
       
           @Override
           public Product ManufactureContainer() {
               return new ContainerProductA();
           }
       
           @Override
           public Product ManufactureMould() {
               return new MouldProductA();
           }
       }
       
       //B厂 - 生产模具+容器产品
       class FactoryB extends Factory{
       
           @Override
           public Product ManufactureContainer() {
               return new ContainerProductB();
           }
       
           @Override
           public Product ManufactureMould() {
               return new MouldProductB();
           }
       }

5.6 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

     //生产工作流程
       public class AbstractFactoryPattern {
           public static void main(String[] args){
               FactoryA mFactoryA = new FactoryA();
               FactoryB mFactoryB = new FactoryB();
               //A厂当地客户需要容器产品A
               mFactoryA.ManufactureContainer().Show();
               //A厂当地客户需要模具产品A
               mFactoryA.ManufactureMould().Show();
       
               //B厂当地客户需要容器产品B
               mFactoryB.ManufactureContainer().Show();
               //B厂当地客户需要模具产品B
               mFactoryB.ManufactureMould().Show();
       
           }
       }

结果
生产出了容器产品A
生产出了容器产品B
生产出了模具产品A
生产出了模具产品B

优点

降低耦合
抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展；
更符合开-闭原则
新增一种产品类时，只需要增加相应的具体产品类和相应的工厂子类即可

简单工厂模式需要修改工厂类的判断逻辑

符合单一职责原则
每个具体工厂类只负责创建对应的产品

简单工厂中的工厂类存在复杂的switch逻辑判断

不使用静态工厂方法，可以形成基于继承的等级结构。

简单工厂模式的工厂类使用静态工厂方法

缺点

抽象工厂模式很难支持新种类产品的变化。

这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

对于新的产品族符合开-闭原则；对于新的产品种类不符合开-闭原则，这一特性称为开-闭原则的倾斜性。

应用场景

在了解了优缺点后，我总结了工厂方法模式的应用场景：

一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
这个系统有多个系列产品，而系统中只消费其中某一系列产品
系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。

you猿人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式

设计模式单例模式利用单例模式的话，我们就可以实现在需要使用时才创建对象，这样就避免了不必要的资源浪费。饿汉方式（线程安全）“饿汉方式” 就是说JVM在加载这个类时就马上创建此唯一的单例实例，不管你用不用，先创建了再说，如果一直没有被使用，便浪费了空间，典型的空间换时间，每次调用的时候，就不需要再判断，节省了运行时间。 public class Singleton { ...
复制链接

扫一扫

专栏目录