设计模式扫荡-创建型模式-单例、工厂、抽象工厂、原型

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量283 收藏 1
点赞数 1
分类专栏： 面向对象 文章标签： java 设计模式 创建型模式 单例模式 抽象工厂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JunSIrhl/article/details/109139944
版权

设计模式扫荡-创建型模式-单例、工厂、抽象工厂、原型

文章目录

单例模式（Singleton Pattern）

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

饿汉单例模式

类加载到内存后，就实例化一个单例，JVM保证线程安全

唯一缺点：不管用到与否，类装载时就完成实例化

public class Mgr01 {
    //将对象设成属性、且静态化、且用final修饰表示不准修改
    private static final Mgr01 INSTANCE = new Mgr01();

    //私有化构造方法，不让外部new此类
    private Mgr01() {};

    //通过方法返回实例
    public static Mgr01 getInstance() {
        return INSTANCE;
    }
	// 获取实例方式 类+方法
    // Mgr01 m2 = Mgr01.getInstance();
}

懒汉单例模式

该模式下类加载的时候不实例化，调用方法的时候再实例化

虽然达到了按需初始化的目的，但却带来线程不安全的问题

public class Mgr03 {
    //作为属性，类加载时先不实例化（new）
    private static Mgr03 INSTANCE; 
	//私有构造方法
    private Mgr03() {
    }
	//调用本方法时再进行实例化
    public static Mgr03 getInstance() {
        //多个线程执行下不安全 会new出多份对象
        if (INSTANCE == null) { 
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }
}

懒汉线程安全单例模式

	//对该方法添加 synchroized关键字 使多个线程串行化执行这个方法
    public static synchroized Mgr03 getInstance() {
        if (INSTANCE == null) { 
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

双重检验锁的单例模式

    public static Mgr06 getInstance() {
        //第一重检验
        if (INSTANCE == null) {          
            //对Mgr06加锁，线程获得该锁对象才能执行下面代码
            synchronized (Mgr06.class) {
                //第二重检验
                if(INSTANCE == null) {  
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

相比方法串行化的方式，该方式减少了同步代码块，提高了效率

在方法串行化模式下，每个线程都得进入方法逻辑判断是否存在对象，在双重检验模式下，线程一旦发现已经存在实例化的对象，直接取用，不用等待

内部类实现单例懒加载

public class Mgr07 {

    private Mgr07() {
    }
    /*
    * 内部类
    * */
    private static class Mgr07Holder {
        //内部类里完成实例化
        private final static Mgr07 INSTANCE = new Mgr07();
    }
    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }
}

该模式下，加载类Mgr07时不会实例化

同样这种模式线程不安全

工厂模式（Factory Pattern）

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

例如：图形作为接口、其实现类有原形、方形、椭圆形，使用工厂模式获取圆形对象、方形对象、椭圆对象等…

其UML类图如下：

//Shape接口类
public interface Shape {
   void draw();
}

//椭圆类 实现Shape接口并重写draw方法
public class Rectangle implements Shape {
   @Override
   public void draw() {
     // ...
   }
}
//方形类
public class Square implements Shape {
   @Override
   public void draw() {
	//...
   }
}
//圆形类
public class Circle implements Shape {
   @Override
   public void draw() {
	//...
   }
}

创建工厂类，用于创建对象

public class ShapeFactory {
    
   //使用 getShape 方法获取调用者想要调用的对象类型
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }
       
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

客户调用方式

      ShapeFactory shapeFactory = new ShapeFactory();
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
      shape1.draw();
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
      shape2.draw();
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
      shape3.draw();

优点：

  • 对象创建的逻辑细节就完成了隐蔽，调用者只需要告诉工厂需要哪个形状的对象即可获得该对象

  • 调用者只关心该对象的接口，即面向接口编程

  • 如果你想添加一个与”形状“具有相同性质的类，只需要实现Shape接口并重写draw方法即可（这保证了程序的扩展性）

缺点：

  • 每次增加一个产品时，都需要增加一个具体类并修改对象创建工厂（例子中的ShapeFactory类），在一定程度上增加了系统的复杂度

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

抽象工厂（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。

该超级工厂又称为其他工厂的工厂。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，每个生成的工厂都能按照工厂模式提供对象。

举例：游戏中的角色 其有一系列武器、一系列食物、一系列交通工具。

武器分为 [现代武器：AK47] [魔法武器：魔法棒]

食物分为 [现代食物：面包] [魔法食物：蘑菇]

交通工具分为 [现代工具：汽车] [魔法道具：扫帚]

如何合理创建这些对象呢？

抽象类及实现类定义（工厂模式）：

//抽象类+抽象方法

//食物
public abstract class Food {
   abstract void eat();
}
public class Bread extends Food{ //面包
    public void printName() {
        System.out.println("wdm");
    }
}
public class MushRoom extends Food{ //蘑菇
    public void printName() {
        System.out.println("dmg");
    }
}

//交通
public abstract class Vehicle { 
    abstract void go();
}

public class Broom extends Vehicle{ //扫帚
    public void go() {
        System.out.println("Car go wuwuwuwuw....");
    }
}
public class Car extends Vehicle{ //汽车
    public void go() {
        System.out.println("Car go wuwuwuwuw....");
    }
}


//武器
public abstract class Weapon {
    abstract void shoot();
}

public class AK47 extends Weapon{ //AK
    public void shoot() {
        System.out.println("tututututu....");
    }
}
public class MagicStick extends Weapon{ //魔法棒
    public void shoot() {
        System.out.println("diandian....");
    }
}

抽象类与接口：

区别仅仅是语义上的不同：一般归结为 - 名词使用抽象类、形容词使用接口

建立抽象工厂，定义创建不同产品族对象的抽象方法：

public abstract class AbastractFactory {
    abstract Food createFood(); //生成食物
    abstract Vehicle createVehicle(); //生成武器
    abstract Weapon createWeapon(); //生成交通工具
}

创建产品族（现代、魔法）工厂，工厂类要继承抽象工厂类并重写抽象工厂的方法

//现代工厂
public class ModernFactory extends AbastractFactory {
    @Override
    Food createFood() {
        return new Bread();
    }
    @Override
    Vehicle createVehicle() {
        return new Car();
    }
    @Override
    Weapon createWeapon() {
        return new AK47();
    }
}

//魔法工厂
public class MagicFactory extends AbastractFactory {
    @Override
    Food createFood() {
        return new MushRoom();
    }
    @Override
    Vehicle createVehicle() {
        return new Broom();
    }
    @Override
    Weapon createWeapon() {
        return new MagicStick();
    }
}

那么，最终调用代码如下

       //使用抽象工厂的具体族实例化来创建对象 
	   AbastractFactory f = new ModernFactory(); //现代工厂
        Vehicle c = f.createVehicle();
        c.go();
        Weapon w = f.createWeapon();
        w.shoot();
        Food b = f.createFood();
        b.printName();
		
	  //魔法工厂略...

以上代码的UML表示为

虚线箭头表示为依赖，可以分为创建create依赖与引用依赖

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象，即例子中现代工厂只提供现代产品…

缺点：产品族扩展比较困难

建造者模式（Builder Pattern）

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。

一个 Builder 类会一步一步构造最终的对象。

该 Builder 类是独立于其他对象的。

建造者模式意图将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

建造者模式主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；

由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定

现有一个复杂对象Person

public class Person {
 int id;
 String name;
 int age;
 double weight;
 int score;
 Location loc;
 // setter getter 略
 
 public Person() {}
}

//地址对象Info
class Location {
 String street;
 String roomNo;

 public Location(String street, String roomNo) {
     this.street = street;
     this.roomNo = roomNo;
 }
}

该对象的特征为参数过多，并且一个对象的创建并不需要设置所有的属性，那么如何优雅的构建这个对象呢？

使用建造者模式

package com.mashibing.dp.builder;

public class Person {

    //属性 ... 略

    //构造方法-设置成私有
    private Person() {}

    /**
      * 由PersonBuider充当构造器
      * Prrson作为属性，返回经过加工的person对象
      */
    public static class PersonBuilder {
        
        Person p = new Person();

        //主属性 非空 返回的是Person
        public PersonBuilder basicInfo(int id, String name, int age) {
            p.id = id;
            p.name = name;
            p.age = age;
            // return this 代表 personbuilder对象 
            return this;
        }

        /*
        *  以下为可选属性
        * */
	   //设置重量
        public PersonBuilder weight(double weight) {
            p.weight = weight;
            return this;
        }
		//设置分数属性
        public PersonBuilder score(int score) {
            p.score = score;
            return this;
        }
		//设置地址属性
        public PersonBuilder loc(String street, String roomNo) {
            p.loc = new Location(street, roomNo);
            return this;
        }
		//返回最终设置好的对象
        public Person build() {
            return p;
        }
    }
}

class Location {
    // ... 同上
}

那么主方法调用：

        // 链式调用 与 builder模式  配套使用
        Person p = new Person.PersonBuilder()
                .basicInfo(1, "zhangsan", 18) //主属性参数只顶你
                //.score(20)
                .weight(200)
                //.loc("bj", "23")
                .build();

其中，建造者Buider与实体Person为强关联-组合关系。
建造者模式的经典应用：

  • Java中的StringBuilder

注意：与工厂模式对比，建造者更重视于一个复杂对象的装配顺序

原型模式（Prototype Pattern）

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。

当直接创建对象的代价比较大时，或一个对象的属性已经确定，需要产生很多相同对象的时候，则采用这种模式。

例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

在Java中，自带了原型模式的API

其基本原理为：在内存级别上进行对象的复制

实现原型模式需要实现标记型接口Cloneable

一般会重写clone()方法

//实现 Cloneable 接口 该接口作为标记接口 在运行时作为被检查的因素
class Person implements Cloneable {
    int age = 8;
    int score = 100;
	//对象属性
    Location loc = new Location("bj", 22);
	//重写Object类的clone() method
    @Override
    public Object clone() throws CloneNotSupportedException {
        //使用默认的克隆策略 即Object类的克隆方法
        return super.clone();
    }
}

class Location {
    String street; //街道信息
    int roomNo; //门牌号
    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }
}

区分深克隆和浅克隆：

以上代码在执行完后，内存模型如下

双方引用类型的属性皆指向同一块内存地址

以上成为浅克隆

如果要实现深克隆，需要对Person原型对象的引用类型属性也进行克隆，并将克隆体的引用类型属性指向新的克隆出来的引用类型

代码如下：

class Person implements Cloneable {
    int age = 8;
    int score = 100;

    Location loc = new Location("bj", 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        //对于引用类型的Location同步进行克隆，并使克隆对象的指针指向它
        p.loc = (Location)loc.clone();
        return p;
    }
}

//Location也需要实现Cloneable接口
class Location implements Cloneable {
    String street;
    int roomNo;
	//含参构造器略...
    
    //覆写clone()方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

深克隆的内存模型如下：

需要注意的是

String类型在Java中作为引用类型是比较特殊的

String类型的对象一般存放于JVM中的运行时常量池，同值的串在常量池中只有一份，所以不管是深克隆还是浅克隆，String类型都指向同一块内存地址

JunSIr_#
关注
专栏目录
创建一个vehicle类并将它声明为抽象类_java_创建一个vehicle接口
weixin_33362096的博客
02-26 2404
在两个名称分别为 Bike 和 Bus 的类中实现 Vehicle 接口。创建一个名 称为 interfaceDemo 的类,在 interfaceDemo 的 main()方法中创建 Bike 和 Bus 对象,并......在两个名称分别为 Bike 和 Bus 的类中实现 Vehicle 接口。创建一个名称为 interfaceDemo 的类,在 interfaceDemo 的 main()...
设计模式扫荡-结构型模式-适配器、桥接、装饰器、享元、代理
JunsIr的技术栈
10-18 318
设计模式扫荡-结构型模式-适配器、桥接、装饰器、享元、代理 " 结构型设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。" 适配器模式（Adapter Pattern） 适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁，它结合了两个独立接口的功能。 适配器模式意图将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 例如 充电器与某个接口不适配，加一个适配器，使得充电头可以插入并正常使用该接
设计模式（单例、工厂）
weixin_48832316的博客
10-22 148
设计模式 创建者模式（帮我们创建对象）： 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 结构型模式： 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式 行为型模式： 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式 创建者模式： 建一个鼠标，汽车，电脑，生产环境都不一样，所以创建者模式多种多样。 单例模式： 保证一个类只有一个实例。并且提供一个访问该实例的全局访问点（提供一个方法来访问这个对象）。
设计模式之工厂模式（创建型）
light的博客
06-25 684
设计模式之工厂模式（创建型）
设计模式----工厂模式
01 10 11 ∞
08-25 410
我们平时出行可以选择的交通工具有汽车、飞机等，假如我们出去旅行，想要选择汽车作为交通工具，我们可以这么写： 1、我们定义一个汽车类（这里使用的是单例模式创建Car，单例模式下可以确保Car类只有一个实例，而且自行实例化，并向整个系统提供这个实例，其它类要生成Car类的实例，只需要调用Car类的getInstance()方法）： public class Car{
经典工厂单例模式典范
12-06
经典的学习典范，经典的学习实例，专供您学习当今最新的主流技术，希望您喜欢。
设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者
JunsIr的技术栈
10-20 443
设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者 文章目录设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者责任链模式（Chain of Responsibility Pattern）命令模式（Command Pattern）迭代器模式（Iterator Pattern）备忘录模式（Memento Pattern）观察者模式（Observer Pattern）状态模式(State Pattern)策略模式（Strategy Pat
六、设计模式之门面模式【Facade】
寓教于乐。教己助人
10-15 48
一个子系统可以有多个门面当门面已经变得臃肿时子系统可以提供不同访问路径门面不参与子系统的逻辑，子系统不知道门面的存在。
中山大学-程序设计新手赛-2023年
04-16
【中山大学程序设计新手赛-2023年】是一场面向编程初学者的比赛，旨在提升参赛者们的编程技能和算法理解。比赛涉及到的核心知识点之一是**时间复杂度**，这是衡量算法效率的重要指标。 时间复杂度是用来估算算法...
perlin-toolkit:动画的Perlin噪波纹理
05-24
极光-温柔的扫荡舞灯 苛性碱-水下模式 雾-浓密的白色薄雾 融合—快速发出明亮的光线 汽油—生锈的详细烟雾 白炽灯—白色电热丝点燃柔和的灯光 墨水—散落的水坑 蕾丝-柔和的白色，带有淡淡的色彩 熔岩-流动的红色...
层次分析matlab代码-SaccadeTrigger:研究在平稳追赶过程中强调追赶扫荡触发的参数
05-23
层次分析matlab代码SaccadeTrigger 该存储库包含的代码可为名为“预测的位置误差在持续的平滑追踪过程中触发追赶”的项目运行心理物理学的眼动追踪双步渐变任务。 对于那些希望复制本研究结果的人，还提供了分析代码...
扫荡波补丁WindowsXP-KB958644-x86-CHS
01-11
标题中的“扫荡波补丁WindowsXP-KB958644-x86-CHS”是指微软针对Windows XP操作系统的一个重要安全更新。扫荡波（Worm.Sasser）是一种著名的蠕虫病毒，它利用系统漏洞进行传播，尤其是针对Windows XP系统中的Server...
UML核心逻辑视图-类图成分及关系的具体说明
JunsIr的技术栈
10-20 4962
UML逻辑视图-类图详解 提示： 对UML基础还不太了解或想查阅学习其他UML图的戳这的戳这UML统一建模语言快速入门.CSDN 类图技术是面向对象方法的核心技术，应用非常广泛，其中，类、对象，以及它们之间的关系是最基本的建模元素。 文章目录UML逻辑视图-类图详解类抽象类接口多重性继承关系泛化关系关联关系-**单向关联**关联关系-双向(标准)的关联关联关系-聚合关联关系-组合依赖关系实例-图书...
UML并发视图_状态图、协作图、时序图、活动图各成分及关系具体说明
JunsIr的技术栈
10-20 4665
UML并发视图-活动图 提示： 对UML基础还不太了解或想查阅学习其他UML图的戳这的戳这UML统一建模语言快速入门.CSDN 活动图可以用于描述系统的工作流程和并发行为，它用于展现参与行为的类所进行的各种活动的顺序关系。 活动图与状态图的区别 活动图中活动的改变不需要事件触发！！！，源活动执行完毕后自动触发转移，转到下一活动 活动图组成元素 动作状态(Activity State) 活...
UML组件视图、部署图、包图简要说明
JunsIr的技术栈
10-20 1864
UML逻辑视图-包图详解 UML统一建模语言入门.CSDN 文章目录UML逻辑视图-包图详解包管理类确定包的关系生成Java代码建立类图关系生成框架代码 包是一个容器，提供对UML元素进行分组的功能，主要表现在：把一个大的系统分解为多个小的系统，分解是控制软件复杂性的重要手段；结构化方法中，对功能进行分解；面向对象方法中，讲相关类放在一起 包管理类 依次创建，在Logical View/ Mai...
UML统一建模语言快速入门
JunsIr的技术栈
10-20 1392
UML统一建模语言入门 基本介绍 UML（统一建模语言Unified Modeling Language）是一种建模（即把对象实体通过适当的抽象，用适当的表现规则描绘出的简洁的模仿品 ，模型有实体的一般特征及规律）语言，用来为面向对象开发系统的产品进行说明、可视化和编制文档的方法。 UML描述了一个系统的静态结构和动态行为。静态结构定义了系统中的重要对象的属性和操作，以及这些**对象之间的相互关系...
UML-用例图成分及关系的具体说明
JunsIr的技术栈
10-20 980
UML用例图详解 提示： 对UML基础还不太了解或想查阅学习其他UML图的戳这的戳这UML统一建模语言快速入门.CSDN 用例模型描述的就是外部参与者所理解的系统功能。画好用例图是由软件需求到最终实现的第一步。 文章目录UML用例图详解用例图的元素如何识别参与者用例之间的关系如何识别用例 用例图的元素 用例： 系统执行的功能或过程，可以由外部对象或系统内部另一个用例启动，一个用例是参与者与计算机...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 231
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
深入解析ATmega128：高性能8位AVR微处理器详解
- **模式选择**：包括Idle、ADC抑制模式、省电模式、掉电模式、Standby和扩展Standby模式。 - **兼容性**：可选择ATmega103兼容模式。 - **I/O**：53个可编程I/O端口，支持TQFP和MLF封装。 5. **电压和速度**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值