设计模式二：建造者，原型，单例

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

weixin_30474613

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

阅读量73

点赞数

文章标签：设计模式 java

原文链接：http://www.cnblogs.com/xiaoyingying/p/8810716.html

版权

https://github.com/tori22/DesignPattern

最近在看大话设计模式，顺带敲了书上的代码。一定要多敲！！！！

之前，讲了三个工厂方法，我们来简单的复习一下

1.抽象工厂: Factory

提供一个创建一系列或相关依赖对象的接口，而无需指定他们具体的类。针对多级结构.

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。

产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，

则几乎所有的工厂类都需要进行修改。

适用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。

总结：生产多系列产品！！！

2.工厂方法

生产单个产品，大工厂下有几个小工厂，每个工厂生产具体的东西

定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂模式使一个类的

实例化延迟到其子类。针对单一结构系统.

适用场景：

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式

假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。

当需要系统有比较好的扩展性时，可以考虑工厂模式

3.简单工厂

就只有一个大工厂，不符合开放--封闭准则

开始今天的学习了。

一.建造者

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

使用建造者模式的好处

1.使用建造者模式可以使客户端不必知道产品内部组成的细节。

2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。

3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

使用建造者模式的场合:

1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是

对象的内部组成构件面临着复杂的变化。

2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

package BuilderPattern;

public abstract class Builder {

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract Product getResult();
}

package BuilderPattern;

public class Client {

    public static void main(String[] args) {
        Director director = new Director();
        Builder builder1 = new ConcrateBuilder1();
        Builder builder2 = new ConcrateBuilder2();

        director.Construct(builder1);
        Product p1 = builder1.getResult();
        p1.show();

        director.Construct(builder2);
        Product p2 = builder2.getResult();
        p2.show();
    }
}
package BuilderPattern;

public class ConcrateBuilder1 extends Builder {

    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.add("部件A");
    }

    @Override
    public void buildPartB() {
        product.add("部件B");
    }

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

public class ConcrateBuilder2 extends Builder {

    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.add("部件x");
    }

    @Override
    public void buildPartB() {
        product.add("部件y");
    }

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

public class Director {

    public void Construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}
package BuilderPattern;

import java.util.ArrayList;
import java.util.List;

public class Product {

    private List<String> parts = new ArrayList<>();

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

    public void show() {
        System.out.println("产品 创建-----");
        for (String part: parts) {
            System.out.println(part);
        }
    }
}

输出为

产品创建-----
部件A
部件B
产品创建-----
部件x
部件y

二.原型

package Prototype;



public class Client {

    public static void main(String[] args) {
        ConcreatePrototype1 p1 = new ConcreatePrototype1("I");
        ConcreatePrototype1 c1 = (ConcreatePrototype1)p1.Clone();

        String str = String.format("id:%s",c1.getId());
        System.out.println(str);

        ConcreatePrototype2 p2 = new ConcreatePrototype2("Y");
        ConcreatePrototype2 c2 = (ConcreatePrototype2)p2.Clone();

        String str2 = String.format("id:%s",c2.getId());
        System.out.println(str2);

    }
}
package Prototype;

public class ConcreatePrototype1 extends Prototype implements Cloneable{

    public ConcreatePrototype1(String id) {
        super(id);
    }
    @Override
    public Prototype Clone() {
        Prototype prototype = null;

        try {
            prototype = (Prototype) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }
}
package Prototype;

public class ConcreatePrototype2 extends Prototype implements Cloneable{

    public ConcreatePrototype2(String id) {
        super(id);
    }
    @Override
    public Prototype Clone() {
        Prototype prototype = null;

        try {
            prototype = (Prototype) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }
}
package Prototype;

public abstract class Prototype {
    private String id;

    public Prototype(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public abstract Prototype Clone();

}

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

使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，

它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

因为以上优点，所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个

循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，

而且可以使系统的整体性能提高很多。

三.单例

package SingletonPattern;

public class Client {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        if(singleton1 == singleton2) {
            System.out.print("两个对象是相同的实例");
        }
    }

}
package SingletonPattern;

public class Singleton {

    private static Singleton mInstance;
    private static final Object mLock = new Object();

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (mInstance == null) {
            synchronized (mLock) {
                if (mInstance == null) {
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }
}

保证一个类仅有一个实例，并提供一个访问它的全局访问点.

让类自身负责保存它的唯一实例，这个类可以保证没有其他实例可以被创建，

并且我还提供了一个访问该实例的方法。这样就使得对唯一的实例可以严格

地控制客户怎样以及何时访问它。

饿汉式

package SingletonPattern;

/*
*****************
* 饿汉式，就是屌丝，穷，担心饿死。类加载就给准备好
* ****************
 */
public class SingletonPattern1 {
    /*
    ********************************
    * 有时会加final修饰符，添加final修饰符之后，指向的引用不能再做更改
    * 这是final的用法：final成员变量表示常量，只能被赋值一次，赋值后不能再改变。
    *
    * 这句话得这么理解
    * 对于一个final变量
    * 如果是基本数据类型的变量，则其数值一旦初始化之后就不能再更改
    * 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象
    * ******************************
     */
    private static final SingletonPattern1 singletonInstance = new SingletonPattern1();

    private SingletonPattern1() {

    }

    public static SingletonPattern1 getSingletonInstance() {
        return singletonInstance;
    }
}

懒汉式

package SingletonPattern;

/*
**********
*  饱汉式（懒汉式）----就是有钱，豪，用的时候再new（线程不安全）
*  *******
 */
public class SingletonPattern2 {
    //这个就不能加final，因为要在其他地方给他再次赋值呢。
    //加了final，那就默认一直是null啦，而且还不能再次给此属性赋值。
    //此属性是静态，那么就是共享数据，多线程并发操作共享数据是有可能的。那么就会出现下面的线程不安全现象。
    private static SingletonPattern2 singletonPattern2;

    private SingletonPattern2() {}

    public static SingletonPattern2 getSingletonPattern2() {
        if (singletonPattern2 == null) {

            //在这个地方,多线程的时候，
            //可能A线程挂起，此属性还是null，那么B线程可能也判断条件OK也进来啦。
            //然后A线程可以执行的时候就会new个对象，线程B也会new个对象。
            //就不能保证内存的唯一性。也就是线程不安全
            singletonPattern2 = new SingletonPattern2();
        }
        return singletonPattern2;
    }

    ///**
    // * 为了应对上述的不安全，可以简单的如下操作给方法添加[synchronized],使之成为同步函数。
    // * 但是：
    // * 在很多线程的情况下，就每个线程访问都得判断锁，效率就是问题。所以，才有后面的[双重锁形式]
    // */
    //public static synchronized SingletonPattern2 getSingletonInstance() {
    //    if (singletonInstance == null) {
    //        singletonInstance = new SingletonPattern2();
    //    }
    //    return singletonInstance;
    //}
}

双重锁（线程不安全）

package SingletonPattern;

public class SingletonPattern3 {
/*
**********************
 双重锁形式
 * 这个模式将同步内容下放到if内部，提高了执行的效率，不必每次获取对象时都进行同步，
 * 只有第一次才同步，创建了以后就没必要了。避免土豪模式下创建单例，可能存在的线程不安全问题。
 * *********************
 */
    private static SingletonPattern3 singletonInstance;

    private SingletonPattern3() {
    }

    /**
     * 静态方法同步的时候，使用的锁，就不能是this，而是类.class
     */
    public static SingletonPattern3 getSingletonInstance() {
        if (singletonInstance == null) {
            //这个地方可能有多个线程，在这排队，ABCD..。
            synchronized (SingletonPattern3.class) {
                if (singletonInstance == null) {
                    //假设第一次A线程走到这，然后，呈挂起状态。这个时候，单例对象还未创建；
                    // 假设此时，B线程也来了判断单例对象==null成立，但是，因为A线程已经给里层的if判断上锁，所以，B只能在外等着。
                    //假设A线程被唤醒，那么，单例就会下面语句赋值，单例对象就创建啦。然后释放锁。B就可以进来啦。
                    //B线程进来之后，先判断单例对象是否为null，发现已经不是null啦，那么就不需要创建啦。
                    //CD线程同样，
                    //再往后面来的，第一个if就进不来啦，那就不会判断锁了。
                    singletonInstance = new SingletonPattern3();
                }
            }
        }
        return singletonInstance;
    }
}