本文详细介绍了Java中的多种设计模式。包括单例模式的八种实现方式及优缺点，工厂模式、抽象工厂模式的原理、代码实现和应用场景，原型模式的基本概念、深浅拷贝及Spring中的应用，建造者模式的构建过程、代码示例和注意事项，为Java开发者提供了设计模式的全面参考。
汇总篇
一、单例模式
1、简介
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
主要解决： 一个全局使用的类频繁地创建与销毁。
何时使用： 当您想控制实例数目，节省系统资源的时候。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项： getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
2、单例模式八种方式
2.1、饿汉式（静态常量）
1.1、代码实例
// 饿汉式（静态常量量）
class Singleton1{
// 1、构造器私有话，防止外部去new
private Singleton1(){
}
// 2、本类内部创建实例
private static final Singleton1 instance = new Singleton1();
// 3、提供一个公有的静态方法，返回实例对象
public static Singleton1 getInstance(){
return instance;
}
}
测试
// 测试
public static void main(String[] args) {
// 新建两个实例
Singleton1 instance = Singleton1.getInstance();
Singleton1 instance1 = Singleton1.getInstance();
// 判断是不是同一个对象
System.out.println(instance == instance1); // ture
System.out.println(instance.hashCode() == instance1.hashCode()); // ture
}
}
1.2、优缺点
优点：
1、这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题
缺点：
在类装载的时候就完成实例化，没有达到Lazy Loading(懒加载)的效果。如果从始至终从未使用过这个实例，则会照成内存的浪费。
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。
结论：
这种单例模式可用，可能造成内存浪费。
2.2、饿汉式（静态代码块）
2.1、代码示例
// 饿汉式（静态代码块）
class Singleton2{
// 1、构造器私有话，防止外部去new
private Singleton2(){
}
// 2、本类内部创建实例
private static final Singleton2 instance;
static { // 在静态代码块中，创建单例对象
instance = new Singleton2();
}
// 3、提供一个公有的静态方法，返回实例对象
public static Singleton2 getInstance(){
return instance;
}
}
测试同上。。
2.2、优缺点
这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类状态的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
结论：
这种单例模式可用，但是可能造成内存浪费。
2.3、懒汉式（线程不安全）
3.1、代码示例
class Singleton3 {
// 1、构造器私有话，防止外部去new
private Singleton3(){}
// 2、本类内部创建实例
private static Singleton3 instance;
// 提供一个静态的公有方法，当使用到该方法时，才去创建instance
// 即懒汉式
public static Singleton3 getInstance(){
if (instance == null){
instance = new Singleton3();
}
return instance;
}
}
3.2、优缺点
1、起到了Lazy Loading 的效果，但是只能在单线程下使用。
2、如果在多线程下，一个线程进入了if判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：
在实际开发中，不要使用这种方式。
2.4、懒汉式（线程安全，加同步方法）
在上面示例上加同步方法，如 synchronized
4.1、代码示例
class Singleton4 {
// 1、构造器私有话，防止外部去new
private Singleton4(){}
// 2、本类内部创建实例
private static Singleton4 instance;
// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，使用synchronized
// 即懒汉式
public static synchronized Singleton4 getInstance(){
if (instance == null){
instance = new Singleton4();
}
return instance;
}
}
4.2、优缺点
1、解决了线程不安全问题。
2、效率太低了。每个线程在想获得类得实例得时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例就够了，后来得想获得该类实例，直接return就行了。方法进行同步效率太低了。
结论：
在实际开发中，不推荐使用这种方式
2.5、懒汉式（线程安全，同步代码块）
将synchronized 方法加在代码块上。
5.1、代码示例
class Singleton5 {
// 1、构造器私有话，防止外部去new
private Singleton5(){}
// 2、本类内部创建实例
private static Singleton5 instance;
// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，使用synchronized代码块
// 即懒汉式
public static Singleton5 getInstance(){
if (instance == null){
synchronized (Singleton5.class){
instance = new Singleton5();
}
}
return instance;
}
}
5.2、优缺点
1、这种方式，本意是想对第四种实现方式得改进，因为前面同步方法效率太低，改为同步产生实例化得代码块。
2、但是这种同步并不能起到线程同步得作用。跟第3种实现方式遇到得情形一致。假如一个线程进入if判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
结论：
在实际开发中，不能使用这种方式。
2.6、双重检查锁
6.1、代码示例
class Singleton6 {
// 1、构造器私有话，防止外部去new
private Singleton6(){}
// 2、本类内部创建实例
/**
* volatile是Java虚拟机提供的轻量级的同步机制，它有３个特性：
* １）保证可见性
* ２）不保证原子性
* ３）禁止指令重排
*/
private static volatile Singleton6 instance;
// 提供一个静态的公有方法，加入双重检查带啊吗，解决线程安全问题，同时解决懒加载问题
public static Singleton6 getInstance(){
if (instance == null){
synchronized (Singleton6.class){
if (instance == null) { // 判断两次
instance = new Singleton6();
}
}
}
return instance;
}
}
6.2、优缺点
1、双重检查概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (instance == null)检查，这样就保证了线程安全了。
2、这样实例化只用执行一次，后面再次访问时，判断if (instance == null),直接retrun实例化对象，也避免得反复进行方法同步
3、线程安全；延迟加载；效率较高
结论：
在实际开发中，推荐使用这种单例设计模式。
2.7、静态内部类
7.1、代码示例
class Singleton7{
// 构造器私有化
private Singleton7(){};
/**
* 当Singleton7类装载时，静态内部类是不会被装载的，
* INSTANCE也只会创建一次
*/
private static class SingletonInstance{
private static final Singleton7 INSTANCE = new Singleton7();
}
/**
* 当调用getInstance时，装载静态内部类，是线程安全的
* @return
*/
public static Singleton7 getInstance(){
return SingletonInstance.INSTANCE;
}
}
7.2、优缺点
- 1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
- 2、静态内部类方式在Singleton类被装载时并不会立即实例化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化
- 3、类的静态属性只会在第一次加载类的时候初始化，所以在这里，jvm帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：
避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
结论：
推荐使用
2.8、枚举
代码示例：
enum Singleton8{
INSTANCE; // 属性
public void method(){
//方法
}
}
优缺点：
- 1、这借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
- 2、这种方式是java作者提倡的方式
结论：
推荐使用
3、源码中的单例模式例子
1、如jdk中的源码Runtime类，采用了饿汉式模式
建议：
建议使用第 1 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 7 种静态内部类方式。如果涉及到反序列化创建对象时，可以尝试使用第 8 种枚举方式。如果有其他特殊的需求，可以考虑使用第 6 种双检锁方式。
二、工厂模式
1、简介
工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。
工厂二字想必大家都不陌生，工厂就是用来建造东西的，我们市面上买的东西比如水杯、玩具、汽车等等都是从工厂生产的，那我们需不需要知道它们是如何生产出来的呢？当然不需要，商家从工厂中直接提货，我们就可以购买了，完全不知道它是如何生产的，这就是工厂方法模式。
说明：就是如果我们的一个接口里面有很多个类型，根据传的type指定走哪个方法，这时我们就可以用工厂模式来优化代码，提高扩展性
意图： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决： 主要解决接口选择的问题。
何时使用： 我们明确地计划不同条件下创建不同实例时。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点： 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
注意事项： 作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
2、代码实现
代码示例：
步骤1：
定义一个接口
interface Shape{
// 定义一个画图的接口
void draw();
}
步骤2：
具体细节都写在实现类上，多个就多个实现类
// 长方形类
class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("这是一个画长方形的具体方法");
}
}
// 正方形类
class Square implements Shape{
@Override
public void draw() {
System.out.println("这是一个画正方形的具体方法");
}
}
// 圆形类
class Circle implements Shape{
@Override
public void draw() {
System.out.println("这是一个画圆形的具体方法");
}
步骤3：
创建一个工厂类，生成基于给定信息的实体类的对象。
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;
}
}
步骤4：
使用该工厂，通过传递类型信息来获取实体类的对象。
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//获取 Circle 的对象，并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取 Rectangle 的对象，并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取 Square 的对象，并调用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
}
}
代码说明：主要就是把判断拿出来当做一个工厂类，接口的具体通过工厂类去跳转，在其子类执行。
3、jdk中使用到的工厂模式
三、抽象工厂模式
1、简介
-
1、为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构；
-
2、抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品；
-
3、将工厂抽象两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂类。这样将简单的工厂类变成了
工厂簇，更利于代码的维护和扩展。 -
4、使用抽象工厂模式一般要满足以下条件：
- 系统中有多个产品族， 每个具体工厂创建同族但属于不同等级的产品；
- 系统一次只可能消费其中某一族产品，即同族的产品一起使用。
意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决： 主要解决接口选择的问题。
何时使用： 系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。
优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点： 产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
注意事项： 产品族难扩展，产品等级易扩展。
2、代码实现
就是将原本只有一个工厂的工厂模式，变成多个工厂，形成工厂簇，然后再弄一个工厂去跳转指定工厂簇的哪一个工厂。
步骤一：
为形状创建一个接口。
interface Shape {
void draw(); // 画图接口
}
步骤 二：
具体细节都写在实现类上，多个就多个实现类
// 长方形类
class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("这是一个画长方形的具体方法");
}
}
// 正方形类
class Square implements Shape{
@Override
public void draw() {
System.out.println("这是一个画正方形的具体方法");
}
}
// 圆形类
class Circle implements Shape{
@Override
public void draw() {
System.out.println("这是一个画圆形的具体方法");
}
步骤 三：
为颜色创建一个接口。
interface Color {
void fill(); //填充接口
}
步骤 四：
具体细节都写在实现类上，多个就多个实现类
class Red implements Color {
@Override
public void fill() {
System.out.println("填充红色");
}
}
class Green implements Color {
@Override
public void fill() {
System.out.println("填充绿色");
}
}
class Blue implements Color {
@Override
public void fill() {
System.out.println("填充蓝色");
}
}
步骤 五
为 Color 和 Shape 对象创建抽象类来获取工厂。
abstract class AbstractFactory{
public abstract Color getColor(String color);
public abstract Shape getShape(String shape);
}
步骤 六
创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
画图的工厂类
class ShapeFactory extends AbstractFactory {
@Override
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;
}
@Override
public Color getColor(String color) {
return null;
}
}
填充颜色的工厂类
class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
public Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if(color.equalsIgnoreCase("GREEN")){
return new Green();
} else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}
步骤 七
创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
步骤 八
使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。
class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("GREEN");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}
输出
3、jdk中使用到的抽象工厂模式
四、原型模式
1、基本介绍
1、原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。通过拷贝这些原型，创建新的对象。
2、原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节。
3、工作原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
意图： 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
主要解决： 在运行期建立和删除原型。
何时使用： 1、当一个系统应该独立于它的产品创建，构成和表示时。 2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3、为了避免创建一个与产品类层次平行的工厂类层次时。 4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
如何解决： 利用已有的一个原型对象，快速地生成和原型对象一样的实例。
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项： 与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
2、代码示例
步骤 1
创建一个实现了 Cloneable 接口的抽象类。要拷贝的对象都来继承这个抽象类
public abstract class Shape implements Cloneable{
private String id;
protected String type;
abstract void draw();
public String getType(){
return type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
步骤 2
创建扩展了上面抽象类的实体类。
class Rectangle extends Shape {
public Rectangle(){
type = "Rectangle";
}
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
class Square extends Shape {
public Square(){
type = "Square";
}
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
class Circle extends Shape {
public Circle(){
type = "Circle";
}
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
步骤 3
创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。
import java.util.Hashtable;
public class ShapeCache {
private static Hashtable<String, Shape> shapeMap
= new Hashtable<String, Shape>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// 对每种形状都运行数据库查询，并创建该形状
// shapeMap.put(shapeKey, shape);
// 例如，我们要添加三种形状
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(),circle);
Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(),rectangle);
}
}
步骤 4
使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());
Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
System.out.println("Shape : " + clonedShape3.getType());
}
}
3、spring中使用的原型模式
spring中的getBean
4、浅拷贝和深拷贝
4.1、浅拷贝：
1、对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
2、对于数据类型是引用数据类型的成员变量，比如说成员变量是个数组、类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
3、浅拷贝是使用默认的clone()方法来实现。，上述例子就是浅拷贝super.clone();
4.2、深拷贝：
1、复制对象的所有基本数据类型的成员变量值。
2、为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直对该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
3、深拷贝实现方式：重写clone方法来实现深拷贝、通过对象的序列化实现深拷贝。
代码示例：
package designMode.advance.prototype;
import java.io.Serializable;
public class DeepCloneableTarget implements Serializable, Cloneable {
private static final long serialVersionUID = 1L;
private String cloneName;
private String cloneClass;
//构造器
public DeepCloneableTarget(String cloneName, String cloneClass) {
this.cloneName = cloneName;
this.cloneClass = cloneClass;
}
//因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
package designMode.advance.prototype;
import java.io.*;
public class DeepProtoType implements Serializable, Cloneable {
public String name; //String 属性
public DeepCloneableTarget deepCloneableTarget;// 引用类型
public DeepProtoType() {
super();
}
//深拷贝 - 通过对象的序列化实现 (推荐)
public Object deepClone() {
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this); //当前这个对象以对象流的方式输出
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepProtoType copyObj = (DeepProtoType)ois.readObject();
return copyObj;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
//关闭流
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e2) {
System.out.println(e2.getMessage());
}
}
}
}
测试：
class test{
public static void main(String[] args) throws CloneNotSupportedException {
DeepCloneableTarget deepCloneableTarget = new DeepCloneableTarget("11", "22");
DeepCloneableTarget clone = (DeepCloneableTarget) deepCloneableTarget.clone();
System.out.println("deepCloneableTarget.hashCode() = " + deepCloneableTarget.hashCode());
System.out.println("clone.hashCode() = " + clone.hashCode());
DeepProtoType p = new DeepProtoType();
p.name = "宋江";
p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
//深拷贝
DeepProtoType p2 = (DeepProtoType) p.deepClone();
System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
}
}
五、建造者模式
1、基本介绍
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
意图： 将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决： 主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用： 一些基本部件不会变，而其组合经常变化的时候。
如何解决： 将变与不变分离开。
应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。
优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
注意事项： 与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
2、代码示例
我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。
我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。
然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个通过结合 Item 来创建不同类型的 Meal 对象的 MealBuilder。BuilderPatternDemo 类使用 MealBuilder 来创建一个 Meal。
步骤 1
创建一个表示食物条目和食物包装的接口。
public interface Item {
public String name();
public Packing packing();
public float price();
}
public interface Packing {
public String pack();
}
步骤 2
创建实现 Packing 接口的实体类。
public class Wrapper implements Packing {
@Override
public String pack() {
return "Wrapper";
}
}
public class Bottle implements Packing {
@Override
public String pack() {
return "Bottle";
}
}
步骤 3
创建实现 Item 接口的抽象类，该类提供了默认的功能。
public abstract class Burger implements Item {
@Override
public Packing packing() {
return new Wrapper();
}
@Override
public abstract float price();
}
public abstract class ColdDrink implements Item {
@Override
public Packing packing() {
return new Bottle();
}
@Override
public abstract float price();
}
步骤 4
创建扩展了 Burger 和 ColdDrink 的实体类。
public class VegBurger extends Burger {
@Override
public float price() {
return 25.0f;
}
@Override
public String name() {
return "Veg Burger";
}
}
public class ChickenBurger extends Burger {
@Override
public float price() {
return 50.5f;
}
@Override
public String name() {
return "Chicken Burger";
}
}
public class Coke extends ColdDrink {
@Override
public float price() {
return 30.0f;
}
@Override
public String name() {
return "Coke";
}
}
public class Pepsi extends ColdDrink {
@Override
public float price() {
return 35.0f;
}
@Override
public String name() {
return "Pepsi";
}
}
步骤 5
创建一个 Meal 类，带有上面定义的 Item 对象。
import java.util.ArrayList;
import java.util.List;
public class Meal {
private List<Item> items = new ArrayList<Item>();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packing().pack());
System.out.println(", Price : "+item.price());
}
}
}
步骤 6
创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。
public class MealBuilder {
public Meal prepareVegMeal (){
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
public Meal prepareNonVegMeal (){
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}
步骤 7
BuiderPatternDemo 使用 MealBuilder 来演示建造者模式（Builder Pattern）。
public class BuilderPatternDemo {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal();
System.out.println("Veg Meal");
vegMeal.showItems();
System.out.println("Total Cost: " +vegMeal.getCost());
Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
System.out.println("\n\nNon-Veg Meal");
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost());
}
}
步骤 8
执行程序，输出结果：
Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0
Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5
3、java中使用的建造者模式
StringBuild类
4、注意事项和细节
- 客户端（使用程序）不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
- 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或者增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。
- 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
- 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。
扫一扫
1675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
