【笔记整理】软考-软件设计师

一、计算机系统

计算机基本单位

单位	名称	简称	换算
位	bit	b
字节	byte	B	1B=8b
千字节	KB		1KB=1024B
兆字节	MB		1MB=1024KB
吉字节	GB		1GB=1024MB
太字节	TB		1TB=1024GB

带宽单位Mbps的b是指Bit（位）
速度单位MB/s的B是指Byte（字节）
1MB/s＝8Mbps

2的次方对照表

2^0＝1
2^1＝2
2^2＝4
2^3＝8
2^4＝16
2^5＝32
2^6＝64
2^7＝128
2^8＝256
2^9＝512
2^10＝1024
2^11＝2048
2^12＝4096
2^13＝8192

硬件

CPU的组成

CPU分为运算器与控制器两大部分

运算器

算术逻辑单元ALU：执行算术运算和逻辑运算。
累加寄存器AC：暂存数据，为ALU提供工作区。
数据缓冲寄存器DR
状态条件寄存器PSW

控制器

程序计数器PC：存储下一条要执行指令的地址，程序员可访问
指令寄存器IR：存储即将执行的指令，还有计数的功能，程序员无法访问
地址寄存器AR：存放的是CPU访问内存单元的地址
指令译码器ID：是把操作码解析成对应的指令操作

原码、反码、补码、移码

原码和反码的取值范围：-127～127
补码和移码的取值范围：-128～127

浮点数

先对阶，小阶向大阶对齐，浮点数尾数向右移
浮点数所能表示的数值范围主要由阶码决定，所表示数值的精度则由尾数决定

寻址

CPU访问速度：
CPU内部通用寄存器>Cache>主存储器>联机磁盘存储器>脱机光盘磁盘存储器

奇偶校验码

只能检错，不能纠错
码距=2，检错能力

海明码

码距≥3，才可能有纠错能力
数据位是n位，校验位是k位，则n和k必须满足以下关系：
2^k-1≥n+k

循环冗余校验码

码距=2，运用模二运算进行检错不能纠错

RISC与CISC

流水线

指令流水线：第1条指令的执行时间+(n-1)*(最长时间段)
不采用流水线/采用流水线 = 加速比
操作周期：最长时间段
吞吐率：最长时间段的倒数
执行n条指令的吞吐率：n/最长时间段

存储器

相联存储器：按内容访问的存储器
虚拟存储器：由主存、辅存构成
CPU:空间局部性、时间局部性

Cache地址映像

直接映像

主存的块与Cache块的对应关系是固定的。
特点：冲突多。③

全相联映像

允许主存的任一块可以调入Cache存储器的任何一个块的空间中。
特点：冲突少。①

组相联映像

特点：冲突较少。②

中断

中断向量：提供中断服务程序的入口地址
中断向量表：所有中断服务的入口地址
中断响应时间：从发出中断请求到进入中断服务程序
保存现场继续执行主程序

输入输出(IO)控制方式

程序查询方式（串行）

①CPU和I/O(外设)只能串行工作
CPU需要一直轮询检查，长期处于忙等状态。CPU利用率低
②一次只能读/写一个字(8bit)
③由CPU将数据放入内存

中断驱动方式（并行）

①I/O设备通过中断信号主动向CPU报告I/O操作已完成
②CPU和I/O（外设）可并行工作
③CPU利用率得到提升
④一次只能读/写一个字(8bit)
⑤由CPU将数据放入内存

直接存储器方式(DMA，并行)

①CPU和I/O（外设）可并行工作
②仅在传送数据块的开始和结束时才需要CPU的干预
③由外设直接将数据放入内存(主存)
④一次读写的单位为“块”而不是字

加密技术与认证技术

明文会出现的问：窃听、篡改、假冒、否认
解决方法：窃听用加密、篡改用摘要、假冒、否认用数字签名

对称加密与非对称加密

1、对称加密(私有密钥加密)
加密和解密是同一把密钥
只有一把密钥

密钥分发有缺陷
①加密解密速度很快
②适合加密大量明文数据
2、非对称加密(公开密钥加密)
加密和解密不是同一把密钥
一共有两把密钥
分别是公钥和私钥

用公钥加密只能用私钥解密
用私钥加密只能用公钥解密
不能通过一把推出另一把

用接收方的公钥加密明文
可以实现防止窃听的效果

密钥分发没有缺陷
①加密解密速度很慢

摘要与数字签名

摘要：将发送的明文进行Hash算法后得到摘要，放在密文后一起发送过去，与接收方解密后的明文进行相同的Hash算法得到的摘要进行对比，如果一致，则没有篡改、否则有篡改。

数字签名：发送方用自己的私钥对摘要进行签名(加密)，得到数字签名放在密文后一起发送过去。

数字证书

CA：权威机构
数字证书：
1、用户向CA机构申请数字证书
2、将个人信息和公钥发给CA机构
3、CA机构颁给用户数字证书
4、数字证书用CA的私钥进行签名(加密)
5、用CA的公钥验证(解密)数字证书
6、得到用的公钥

认证处理主动攻击。
公钥加密认证。
私钥解密签名，数字签名确保信息的真实性。

加密算法

对称密钥(私钥、私有密钥加密)算法

(共享密钥加密算法)
1、DES
2、3DES
3、RC-5
4、IDEA
5、AES
6、RC4

非对称密钥(公钥、公开密钥加密)算法

1、RSA
2、ECC
3、DSA

可靠性

1、串联系统

R=R1R2...RN

2、并联系统

R=1-(1-R1)(1-R2)...(1-RN)

与、或、同或、异或

与（AND）&

全1为1，有0为0

或（OR）|

全0为0，有1为1

异或（XOR）^

相同为0，不同为1

同或（XNOR）

相同为1，不同为0

二、程序设计语言

编译程序和解释程序

解释器

翻译时不生成独立的目标程序，解释程序和源程序都参与程序运行过程

编译器

翻译时独立生成目标程序，源程序和编译程序不再参与目标程序的运行过程

编译、解释与翻译阶段

编译器方式中间代码生成和代码优化不是必要的，可省略
即在词法分析、语法分析、语义分析阶段后直接生成目标代码

编译过程

源程序→词法分析→记号流→词法分析→分析树（语法树）→语义分析

词法分析

词法分析阶段的主要作用是分析构成程序的字符及
由字符按照构造规则构成的符号是否符合程序语言的规定

语法分析

语法分析阶段的主要作用是
对各条语句的结构进行合法性分析
分析程序中的句子结构是否正确

语法分析阶段可以发现程序中的所有语法错误

语义分析

语义分析阶段的主要作用是进行类型分析和检查

语义分析阶段不能发现程序中所有的语义错误
语义分析阶段可以发现静态语义错误
不能发现动态语义错误，动态语义错误运行时才能发现

传值调用与传址调用

传值调用

将实参的值传递给形参，实参可以是变量、常量和表达式。
不可以实现形参和实参间双向传递数据的效果。

传引用(地址)调用

将实参的地址传递给形参，形参必须有地址，实参不能是常量(值)、表达式。
可以实现形参和实参间双向传递数据的效果，即改变形参的值同时也改变了实参的值。

中间代码生成

常见的中间代码有：后缀式、三地址码、三元式、四元式和树(图)等形式。

上下文无关文法

大多数程序设计语言的语法规则用上下文无关文法描述

中缀、后缀表达式转换

优先级：1、()；2、*、/；3、+、-
?: +-*/
中缀：a?b
后缀：ab?

语法树中、后序遍历

中序：左根右
后序：左右根

三、知识产权

著作权（版权）

发表权受时间限制，署名权、修改权、保护作品完整权永远属于作者。

专利地域性

在哪申请，就在哪受保护

计算机软件著作权（50年）

计算机软件著作权受到《中华人民共和国著作权法》和《计算机软件保护条例》这两个法律的保护

职务作品

只享有署名权，其他权归公司所有

委托开发

有合同，按合同约定，无合同，著作权由受委托人享有

专利申请

先申请先得，同一天申请协商

商标权

10年内有效，可无限延长

商标注册

先注册先得，同一天注册先使用先得，同一天注册都没使用过协商

四、数据库

三级模式结构

概念模式（基本表）
外模式（视图）
内模式（存储文件）

两级映像

模式/内模式映像
数据的物理独立性：为了保证应用程序能够正确执行，需要修改概念模式和内模式之间的映像。

外模式/模式映像
数据的逻辑独立性：为了保证应用程序能够正确执行，需要修改外模式和概念模式之间的映像。

范式

第一范式（1NF，属性原子化）

消除非主属性对码的部分函数依赖
部分函数依赖导致数据冗余、更新异常

第二范式（2NF，消除部分函数依赖）

消除非主属性对码的传递函数依赖
关系模式分解消除部分函数依赖
传递函数依赖导致数据冗余、更新异常

第三范式（3NF，消除传递函数依赖）

消除主属性对码的部分和传递函数依赖

BC范式（BCNF，消除主属性对候选码的部分和传递依赖）

消除非平凡且非函数依赖的多值依赖

第四范式（4NF）

数据库设计

数据库设计策略：自顶向下、自底向上
数据库设计的步骤，简称新奥尔良法：
1、用户需求分析。
2、概念设计。
概念结构设计是对信息分析和定义，描述概念模型较理想的是采用E-R方法。
3、逻辑设计。
4、物理设计。
逻辑模型在计算机中的具体实现方案。

需求分析阶段

成果：系统需求说明书，主要包括数据流图、数据字典、各种说明性表格、统计输出表和系统功能结构图。

概念结构设计阶段

1、选择局部应用
2、逐一设计分E-R图
3、E-R图合并

1、属性冲突
2、命名冲突
3、结构冲突

逻辑结构设计

1、实体向关系模式的转换
2、联系向关系模式的转换

事务管理

1、原子性：事务是原子的，要么都做，要么都不做。
2、一致性：事务执行的结果必须保证数据库从一个一致性状态变到另一个一致性状态。因此，当数据库只包含成功事务提交的结果时，称数据库处于一致性状态。
3、隔离性：事务相互隔离。当多个事务并发执行时，任一事务的更新操作直到其成功提交的整个过程，对其他事务都是不可见的。
4、持久性：一旦事务成功提交，即使数据库崩溃，其对数据库的更新操作也将永久有效。

数据库备份与恢复

备份方法

1、静态转储和动态转储。
2、海量转储和增量转储。
3、日志文件。

恢复

1、反向扫描文件日志（即从最后向前扫描日志文件），查找该事务的更新操作。
2、对事务的更新操作执行逆操作。
3、继续反向扫描日志文件，查找该事务的其他更新操作，并做同样的处理，直到事务的开始标志。

封锁

并发控制的主要技术是封锁
基本封锁的类型：排它锁（X锁或写锁）和共享锁（S锁或读锁）

分布式数据库

五、面向对象

对象和消息

对象

一个对象把属性和行为封装为一个整体
对象是一个程序模块
一个对象通常可由对象名、属性、方法3个部分组成

消息

对象之间进行通信的一种构造叫作消息

方法重载

方法名相同（同名），但是参数个数或者参数类型不同叫方法重载

封装

封装是一种信息隐藏的技术。其目的是使对象的使用者和生产者分离
对象是封装数据和行为的整体
关键字this可以用于区分同名的对象属性和局部变量名

继承

继承是父类和子类之间共享数据和方法的机制
只从一个父类得到继承，叫作“单重继承”
如果一个子类有两个或更多个父类，则称为“多重继承”

多态

在收到消息时，对象要予以响应
不同的对象收到同一消息可以产生完全不同的结果，这一现象称为多态
多态的实现受到继承的支持

参数多态

应用比较广泛的多态，被称为最纯的多态

包含多态

在许多语言中都存在，最常见的例子就是子类型化，即一个类型是另一个类型的子类型

过载多态

同一个名字在不同的上下文所代表的含义不同

强制多态

面向对象设计原则

单一责任原则

开放-封闭原则

里氏替换原则

依赖倒置原则

接口分离原则

共同封闭原则

共同重用原则

面向对象分析与设计

面向对象分析

面向对象分析目的是为了获得对应用问题的理解
包含5个活动：
1、认定对象
2、组织对象
3、描述对象间的相互作用
4、确定对象的操作
5、定义对象的内部信息

面向对象设计

包含5个活动：
1、识别类及对象
2、定义属性
3、定义服务
4、识别关系
5、识别包

六、UML

UML4种关系

依赖关系

1、一个事物发生变化会影响另一个事物的语义
2、类的方法中定义了另外一个类的对象，那是这个类依赖另外一个类
3、一个类需要用到什么那就是依赖

实现关系

1、在接口和实现它们的类或构件之间
2、在用例和实现它们的协作之间

泛化关系

1、特殊/一般关系，特殊元素（子元素）的对象可替代一般元素（父元素）的对象。

关联关系

1、是一种结构关系，描述了一组链，链是对象之间的连接
聚集：是一种特殊类型的关联，它描述了整体和部分间的结构关系

UML图

类图

展现了一组对象、接口、协作和它们之间的关系
类图通常包括下述内容：
1、类
2、接口
3、协作
4、依赖、泛化和关联关系


对系统的静态设计视图建模时：
1、对系统的词汇建模
2、对简单的协作建模
3、对逻辑数据库模式建模

对象图

展现了某一时刻一组对象以及它们之间的关系
对象图一般包括：对象和链

用例图

用例图展现了一组用例、参与者以及它们之间的关系
用例图通常包括下述内容：
1、用例
2、参与者
3、用例之间的扩展关系（<<extend>>）和包含关系（<<include>>），参与者和用例之间的关联关系，用例与用例以及参与者与参与者之间的泛化关系。

场景：
1、对系统的语境建模
2、对系统的需求建模

包含关系

包含关系描述的是一个用例需要某种功能，而该功能被另外一个用例定义，那么在用例的执行过程中，就可以调用已经定义好的用例。表示符号：<<include>>

扩展关系

用一个用例（可选）扩展另一个用例（基本例）的功能，将一些常规的动作放在一个基本用例中，将可选的或只在特定条件下才执行的动作放在它的扩展用例中。表示符号：<<extend>>

泛化关系

泛化是一种特殊/一般关系，特殊元素（子元素）的对象可替代一般元素（父元素）的对象
泛化关系用一条带有空心箭头的实线，它指向父元素

交互图

交互图用于对系统的动态方面进行建模
交互图一般包含对象、链、消息

序列图（顺序图）

多个对象与一个用例的行为
序列图是场景的图形化表示，描述了以时间顺序组织的对象之间的交互活动

序列图有两个不同于通信图的特征：
（1）序列图有对象生命线
对象生命线是一条垂直的虚线，表示一个对象在一段时间内存在
（2）序列图有控制焦点
控制焦点是一个瘦高的矩形，表示一个对象执行一个动作所经历的时间段，矩形的顶部表示动作的开始，底部表示动作的结束

通信图（协作图）

通信图（别名：协作图）强调收发消息的对象的结构组织

通信图有两个不同于序列图的特性：
（1）通信图有路径
（2）通信图有顺序号
沿同一个链可以显示许多消息（可能发自不同的方向），并且每个消息都有唯一的一个顺序号
通信图展现了对象之间的消息流及其顺序
序列图和通信图是同构的，它们之间可以相互转换

状态图

状态图展现了一个状态机，它由状态、转换、事件和活动组成
强调对象行为的事件顺序
状态图对系统的动态方面建模
当对系统、类或用例的动态方面建模时，通常是对反应型对象建模

状态

状态是任何可以被观察到的系统行为模式，一个状态代表系统的一种行为模式
状态图的状态主要有：初态（即初始状态）、终态（即最终状态）和中间状态

转换和事件

是在某个特定时刻发生的事情，它是对引起系统做动作或（和）从一个状态转换到另一个状态的外界事件的抽象
在表示状态转换的箭头线上标出触发转换的事件表达式
如果箭头线上未标明事件，则表示在源状态的内部活动执行完之后自动触发转换
表达式：事件说明[监护条件]/动作表达式

活动图

活动图是一种特殊的状态图，它展现了在系统内从一个活动到另一个活动的流程。

包括活动状态和动作状态。转换和对象。
活动图可以表示分支、合并、分岔和汇合。
两种活动图的方式：
1、对工作流建模
2、对操作建模

构件图（组件图）

构件图展现了一组构件之间的组织和依赖。构件图专注于系统的静态实现视图。
通常把构件映射为一个或多个类、接口或协作。

部署图

展现了系统的软件与硬件之间的关系

场景：
1、在实施阶段使用

UML图总结

静态建模

类图、对象图、用例图

动态建模

序列图（顺序图，时序图）、通信图（协作图）、状态图、活动图

物理建模

构件图（组件图）、部署图

交互图

序列图（顺序图，时序图）、通信图（协作图）

图	关系
类图	一组对象、接口、协助和它们之间的关系
对象图	某一时刻一组对象之间的关系
用例图	一组用例与参与者之间的关系
序列图	多个对象与一个用例的行为
通信图	对象之间的消息流及顺序
状态图
活动图	一个活动到另一个活动的流程
构件图	一组构件之间的组织及依赖
部署图	软件与硬件的关系

七、设计模式

创建型设计模式

简单工厂模式

简单工厂模式属于创建型模式，但不属于23种设计模式之一，
定义：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。

三类角色：
工厂（核心）：负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象。
抽象产品：工厂类所创建的对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象。
具体产品：简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法。

简单工厂模式代码

public class SimpleFactory {
   
    public static void main(String[] args) {
   
        Product productA = Factory.createProduct("A");
        productA.info();
        
        Product productB = Factory.createProduct("B");
    }
}

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

class Factory {
   
    public static Product createProduct(String type) {
   
        Product product = null;
        
        switch (type) {
   
            case "A":
                product = new ProductA();
                break;
            case "B":
                product = new ProductB();
                break;
            default:
                System.out.println("没有 " + type + " 类型的产品！");
                break;
        }
        
        return product;
    }
}

class ProductA extends Product {
   
    
    @Override
    public void info() {
   
        System.out.println("产品的信息：A");
    }
}

class ProductB extends Product {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：B");
    }
}

工厂方法模式（Factory Method）

意图

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

结构

1、Product定义工厂方法所创建的对象的接口。
2、ConcreteProduct实现Product接口。
3、Creator声明工厂方法，该方法返回一个Product类型的对象。
4、ConcreteCreator重定义工厂方法返回一个ConcreteProduct实例。

适用性

1、当一个类不知道它所必须创建的对象的类的时候。
2、当一个类希望由它的子类来指定它所创建的对象的时候。
3、（了解即可）当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

工厂方法模式代码

public class FactoryMethod {
   
    public static void main(String[] args) {
   
        Factory factoryA = new FactoryA();
        // 父类 对象名 = new 子类();

        Product productA = factoryA.createProduct();
        // Product productA = new ProductA();
        productA.info();

        Factory factoryB = new FactoryB();

        Product productB = factoryB.createProduct();
        productB.info();
    }
}

// class Factory
interface Factory {
   
    public Product createProduct();
}

class FactoryA implements Factory {
   

    @Override
    public Product createProduct() {
   
        return new ProductA();
    }
}

class FactoryB implements Factory {
   

    @Override
    public Product createProduct() {
   
        return new ProductB();
    }
}

// abstract class Product
interface Product {
   
    // public abstract void info();
    public void info();
}

// class ProductA extends Product
class ProductA implements Product {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：A");
    }
}

// class ProductB extends Product
class ProductB implements Product {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：B");
    }
}

抽象工厂模式（Abstract Factory）

意图

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

结构

1、AbstractFactory声明一个创建抽象产品对象的操作接口。
2、ConcreteFactory实现创建具体产品对象的操作。
3、AbstractProduct为一类产品对象声明一个接口。
4、ConcreteProduct定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。
5、Client仅使用由AbstractFactory和AbstractProduct类声明的接口。

适用性

1、一个系统要独立于它的产品的创建、组合和表示时。
2、一个系统要由多个产品系列中的一个来配置时。
3、当要强调一系列相关的产品对象的设计以便进行联合使用时。
4、当提供一个产品类库，只想显示它们的接口而不是实现时。

抽象工厂模式代码

public class AbstractFactory {
   
    public static void main(String[] args) {
   
        Factory factory1 = new Factory1();

        ProductA productA = factory1.createProductA();
        productA.info();

        Factory factory2 = new Factory2();

        ProductB productB = factory2.createProductB();
        productB.info();
    }
}

interface Factory {
   
    public ProductA createProductA();
    public ProductB createProductB();
}

class Factory1 implements Factory {
   

    @Override
    public ProductA createProductA() {
   
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
   
        return new ProductB1();
    }
}

class Factory2 implements Factory {
   

    @Override
    public ProductA createProductA() {
   
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
   
        return new ProductB2();
    }
}

interface ProductA {
   
    public void info();
}

class ProductA1 implements ProductA {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：A1");
    }
}

class ProductA2 implements ProductA {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：A2");
    }
}

interface ProductB {
   
    public void info();
}

class ProductB1 implements ProductB {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：B1");
    }
}

class ProductB2 implements ProductB {
   

    @Override
    public void info() {
   
        System.out.println("产品的信息：B2");
    }
}

生成器模式（Builder）

意图

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

结构

1、Builder为创建一个Product对象的各个部件指定抽象接口。
2、ConcreteBuilder实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，提供一个检索产品的接口。
3、Director构造一个使用Builder接口的对象。
4、Product表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。

适用性

1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2、当构造过程必须允许被构造的对象有不同的表示时。

生成器模式代码

import java.util.*;

public class Main {
   
    public static void main(String[] args) {
   
        Director director = new Director();

        Builder builder1 = new Builder1();
        director.Construct(builder1);
        Product product1 = builder1.getResult();
        product1.show();

        Builder builder2 = new Builder2();
        director.Construct(builder2);
        Product product2 = builder2.getResult();
        product2.show();
    }
}

class Director {
   
    public void Construct(Builder builder) {
   
        builder.BuildPart();
    }
}

abstract class Builder {
   
    public abstract void BuildPart();
    public abstract Product getResult();
}

class Builder1 extends Builder {
   
    Product product = new Product();

    @Override
    public void BuildPart() {
   
        product.Add("A");
        product.Add("B");
        product.Add("C");
        product.Add("D");
        product.Add("E");
        product.Add("F");
    }

    @Override
    public Product getResult() {
   
        return product;
    }
}

class Builder2 extends Builder {
   
    Product product = new Product();

    @Override
    public void BuildPart() {
   
        product.Add("A");
        product.Add("B");
        product.Add("C");
    }

    @Override
    public Product getResult() {
   
        return product;
    }
}

class Product {
   
    List<String> parts = new ArrayList<String>();

    public void Add(String part) {
   
        parts.add(part);
    }

    public void show() {
   
        System.out.print("产品的组成：");
        for (String s : parts)
            System.out.print(s + " ");

        System.out.print("\n");
    }
}

原型模式（Prototype）

意图

用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

结构

1、Prototype声明一个复制自身的接口。
2、ConcretePrototype实现一个复制自身的操作。
3、Client让一个原型复制自身从而创建一个新的对象。

适用性

1、当一个系统应该独立于它的产品创建、构成和表示时。
2、当要实例化的类是在运行时刻指定时。
3、为了避免创建一个与产品类层次平行的工厂类层次时。
4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们，可能比每次用合适的状态手工实例化该类更方便一些。

原型模式代码

public class Main {
   
    public static void main(String[] args) {
   
        Product product1 = new Product(2022, 5.28);
        System.out.println(product1.getId() + " " + product1.getPrice());

        // Product product2 = new Product(2022, 5.28);
        Product product2 = (Product) product1.Clone();
        System.out.println(product2.getId() + " " + product2.getPrice());

        Product product3 = (Product) product1.Clone();
        System.out.println(product3.getId() + " " + product3.getPri