zoukankan      html  css  js  c++  java
  • 设计模式复习【2】- 创建类模式

    1. 单例模式

    1. 定义

      • 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例
    2. 代码

      /**
      * 单例模式-饿汉形式
      * @author emma_zhang
      * @date 2019/2/15
      */
      public class SingletonForHunger {
      private static final SingletonForHunger SINGLETON_FOR_HUNGER = new SingletonForHunger();
      
      private SingletonForHunger() {
          // 限制产生多个实例
      }
      /**
       * 访问实例
       */
      public static SingletonForHunger getSingletonForHunger() {
          return SINGLETON_FOR_HUNGER;
      }
      
      public static void doSomething() {
          // 其他方法,尽量使用static
      }
      }
      
      /**
      * 单例模式-懒汉形式
      *
      * @author emma_zhang
      * @date 2019/2/15
      */
      public class SingletonForLazy {
      private static SingletonForLazy singletonForLazy = null;
      
      private SingletonForLazy() {
          // 限制产生多个对象
      }
      
      /**
       * 产生实例对象,必须要加同步,不然在多线程下可能出错
       *
       * @return 实例对象
       */
      public synchronized static SingletonForLazy getSingletonForLazy() {
          if (singletonForLazy == null) {
              singletonForLazy = new SingletonForLazy();
          }
          return singletonForLazy;
      }
      }
      

        

    3. 使用场景

      • 要求生成唯一序列化的环境
      • 在整个项目中需要一个共享访问或者共享数据点
      • 创建一个对象需要消耗的资源过多,如要访问IO和数据库等资源
      • 需要定义大量的静态变量和静态方法(工具类)的环境

    2. 工厂方法模式

    1. 定义

      • 定义一个用于创建对象的接口,让子类决定实例化哪一个类
      • 工厂方法使一个类的实例化延迟到其子类
    2. 通用源码

      /**
      *  抽象产品类
      * @author emma_zhang
      * @date 2019/2/18
      */
      public abstract class Product {
      /**
       * 产品的公共方法
       */
      public void method(){
      
      }
      
      /**
       * 抽象方法
       */
      public abstract void method2();
      }
      /**
      * 具体产品类
      *
      * @author emma_zhang
      * @date 2019/2/18
      */
      public class ConcreteProduct1 extends Product {
      @Override
      public void method2() {
      
      }
      }
      /**
      * 抽象工厂类
      *
      * @author emma_zhang
      * @date 2019/2/18
      */
      public abstract class Creator {
      /**
       * 输入参数可以自行匹配,通常为string,enum,class等
       *
       * @param c
       * @param <T>
       * @return
       */
      public abstract <T extends Product> T createProduct(Class<T> c);
      }
      /**
      * 具体工厂类
      *
      * @author emma_zhang
      * @date 2019/2/18
      */
      public class ConcreteCreator extends Creator {
      @Override
      public <T extends Product> T createProduct(Class<T> c) {
          Product product = null;
          try {
              product = (Product)Class.forName(c.getName()).newInstance();
          } catch (Exception e) {
              // 处理异常
              e.printStackTrace();
          }
          return (T)product;
      }
      }
      /**
      * 场景类
      *
      * @author emma_zhang
      * @date 2019/2/18
      */
      public class Client {
      public static void main(String[] args) {
          Creator creator = new ConcreteCreator();
          Product product = creator.createProduct(ConcreteProduct1.class);
          // 继续业务处理
      }
      }
      

        

    3. 应用场景

      • new一个对象的替代品
      • 需要灵活的,可扩展的框架时,考虑使用工厂方法模式
    4. 扩展

      • 简单工厂模式:将ConcreteCreator中改为静态【static】方法,同时去掉抽象类,简化了类的创建过程
      • 升级为多个工厂方法:一个具体类对应一个工厂

    3. 抽象工厂模式

    1. 定义

      • 为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类
      • 在场景类中,没有任何一个方法与实现类有关系,对于一个产品来说,我们只要知道它的工厂方法就可以直接产生一个产品对象,无须关系它的实现类
    2. 通用源码

      /**
      * 抽象产品类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public abstract class AbstractProductA {
      public void sharedMethod() {
          // 每个产品共有的方法
      }
      
      /**
       * 共有的方法,但不同的实现
       */
      public abstract void doSomething();
      }
      /**
      * 产品A1的实现类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class ProductA1 extends AbstractProductA {
      @Override
      public void doSomething() {
          System.out.println("产品A1的实现方法");
      }
      }
      /**
      * 产品A2的实现类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class ProductA2 extends AbstractProductA {
      @Override
      public void doSomething() {
          System.out.println("产品A2的实现类");
      }
      }
      /**
      * 抽象产品类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public abstract class AbstractProductB {
      public void sharedMethod() {
          // 每个产品共有的方法
      }
      
      /**
       * 共有的方法,但不同的实现
       */
      public abstract void doSomething();
      }
      /**
      * 产品B1的实现类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class ProductB1 extends AbstractProductB {
      @Override
      public void doSomething() {
          System.out.println("产品B1的实现方法");
      }
      }
      /**
      * 产品B2的实现类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class ProductB2 extends AbstractProductB {
      @Override
      public void doSomething() {
          System.out.println("产品B2的实现类");
      }
      }
      /**
      * 抽象工厂
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public abstract class AbstractCreator {
      /**
       * 构建产品A
       *
       * @return 产品A
       */
      public abstract AbstractProductA createProductA();
      
      /**
       * 构建产品B
       *
       * @return 产品B
       */
      public abstract AbstractProductB createProductB();
      }
      /**
      * 产品等级1的实现
      *
      * @author emma_zhan
      * @date 2019/2/19
      */
      public class Creator1 extends AbstractCreator {
      @Override
      public AbstractProductA createProductA() {
          return new ProductA1();
      }
      
      @Override
      public AbstractProductB createProductB() {
          return new ProductB1();
      }
      }
      /**
      * 产品等级2的实现
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class Creator2 extends AbstractCreator {
      @Override
      public AbstractProductA createProductA() {
          return new ProductA2();
      }
      
      @Override
      public AbstractProductB createProductB() {
          return new ProductB2();
      }
      }
      /**
      * 场景类
      *
      * @author emma_zhang
      * @date 2019/2/19
      */
      public class Client {
      public static void main(String[] args) {
          AbstractCreator creator1 = new Creator1();
          AbstractCreator creator2 = new Creator2();
          AbstractProductA a1 = creator1.createProductA();
          AbstractProductA a2 = creator2.createProductA();
      
          AbstractProductB b1 = creator1.createProductB();
          AbstractProductB b2 = creator2.createProductB();
      
          // 业务逻辑从这里开始。。。。
      }
      }
      

        

    3. 优点

      • 封装性:实现类不是由高层模块关心,而是由工厂类负责创造
      • 产品族的约束为非公开状态
    4. 缺点

      • 产品族扩展很困难,需要修改所有类,横向扩展容易,纵向扩展困难

    4. 建造者模式

    1. 定义

      • 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的标识
    2. 通用源码

      /**
      * 产品类-实现模板方法模式
      *
      * @author duogui.zq
      * @date 2019/2/21
      */
      public class Product {
      public void doSomething() {
          // 独立业务逻辑
      }
      }
      /**
      * 抽象建造者-规范产品的组建
      *
      * @author duogui.zq
      * @date 2019/2/21
      */
      public abstract class Builder {
      /**
       * 设置产品的不同部分,已获得不同的产品
       */
      public abstract void setPart();
      
      /**
       * 建造产品
       *
       * @return
       */
      public abstract Product buildProduct();
      }
      /**
      * 建造者 有多少个产品就有多少个建造者,这些产品类具有相同的接口或者抽象类
      *
      * @author duogui.zq
      * @date 2019/2/21
      */
      public class ConcreteProduct extends Builder {
      private Product product = new Product();
      
      @Override
      public void setPart() {
      
      }
      
      @Override
      public Product buildProduct() {
          return product;
      }
      }
      /**
      * 导演类
      *
      * @author duogui.zq
      * @date 2019/2/21
      */
      public class Director {
      private Builder builder = new ConcreteProduct();
      
      public Product getProduct() {
          builder.setPart();
          /**
           * 设置不同的零件,产生不同的产品
           */
          return builder.buildProduct();
      }
      }
      

        

    5. 原型模式

    1. 定义

      • 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
      • 核心方法:clone方法
    2. 通用源码:

      /**
      * 原型模式
      *
      * @author emma_zhang
      * @date 2019/2/26
      */
      public class PrototyprClass implements Cloneable {
      
      @Override
      public PrototyprClass clone() {
          PrototyprClass prototyprClass = null;
          try {
          //
              prototyprClass = (PrototyprClass) super.clone();
          }catch (CloneNotSupportedException e) {
              // 异常处理
          }
          return prototyprClass;
      }
      }
      

        

    3. 使用场景

      • 需要在一个循环体内产生多个对象时
      • 根据一个对象产生多个对象,并且需要对多个对象进行不同的修改时 
    4. 注意事项

      • 执行clone操作时构造函数是不会进行执行的,Object类中的clone方法的原理是从内存中(具体是从堆内存中)以二进制流的方法进行拷贝,重新分配一个内存块,那构造函数就不会被执行
      • 加final关键字的成员变量不能进行clone
    5. 深拷贝和浅拷贝

      • 浅拷贝:只拷贝本对象,其对象内部的数组,引用对象等都不拷贝,还是指向原生对象的内部元素地址,clone就是浅拷贝,原生类型,类似int,long,char等都会被拷贝
      • 深拷贝:完全的拷贝
    6. 深拷贝的实例

      /**
      * 深拷贝
      *
      * @author emma_zhang
      * @date 2019/2/26
      */
      public class DeepClone implements Cloneable {
      private ArrayList<String> list = new ArrayList<>();
      
      @Override
      public DeepClone clone() {
          DeepClone deepClone = null;
          try {
              deepClone = (DeepClone)super.clone();
              deepClone.list = (ArrayList<String>)this.list.clone();
          } catch (CloneNotSupportedException ex) {
              ex.printStackTrace();
          }
          return deepClone;
      }
      }
      

        

     

  • 相关阅读:
    go 接口
    jboss 7部署cas3.4.11
    HP LoadRunner 11 破解及license
    JBoss7快速入门
    jboss7的服务器开启和关闭命令
    proc/sys/net/ipv4/下各项的意义
    JAVA使用EPoll来进行NIO处理的方法(转)
    Java NIO类库Selector机制解析(下)
    Java NIO类库Selector机制解析(上)
    mysql 性能优化方向
  • 原文地址:https://www.cnblogs.com/Gabby/p/10500073.html
Copyright © 2011-2022 走看看