Java设计模式二（单例模式、建造者模式）_java建造者模式冲突-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_35366908/article/details/68488395

单例模式（Singleton Pattern:Ensure a class has only one instance, and provide a global point of access to it. ）有且只有一个元素的集合：

我们都知道在Java中单例模式的定义是：“一个类有且仅有一个实例，并且自行实例化向整个系统提供”，这个模式是在设计模式中最简单的形式之一。也是我在实际应用中最早接触的模式，在实际项目中往往会用到这种模式，如app中的application类、自行封装的网络请求类，一般都会使用单例模式创建一个实例，供全局使用。

单例模式的优缺点：(来自百科)

优点

1、实例控制单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

2、灵活性因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点

1、开销虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

2、可能的开发混淆使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

3、对象生存期不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NETFramework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

从代码的角度分析优点（摘自博客http://blog.youkuaiyun.com/fu222cs98/article/details/23557141）

1、由于单例模式在内存中只有一个实例，减少了内存开支

2、由于单例模式只生成一个实例，所以减少了系统的性能开销

3、单例模式可以避免对资源的多重占用

4、单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

缺点

1、单例模式扩展困难

2、单例模式对测试是不利的

3、单例模式与单一职责原则有冲突

一个类应该只实现一个

逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中

使用场景：（参考http://blog.youkuaiyun.com/likika2012/article/details/11483167）

工具类、全局

实例：

最常用的单例模式有两种类型写法，分别是懒汉式和饿汉式

懒汉式

但是懒汉式天生是线程不安全的，没有考虑线程安全问题，它在并发的环境下可能产生多个Singleton实例

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}

解决线程安全问题可以用同步锁

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

或者双重检查锁定

public static Singleton getInstance() {  
        if (singleton == null) {    
            synchronized (Singleton.class) {    
               if (singleton == null) {    
                  singleton = new Singleton();   
               }    
            }    
        }    
        return singleton;   
    }

饿汉式：类一旦加载，就把单例初始化完成，

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

我个人在实际项目中比较喜欢懒汉式的创建方式，O(∩_∩)O哈哈~怎么选择主要看个人喜好

***********************************************************************************************************************************************

建造者模式（将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。[来自搜狗百科]）

建造者模式的角色：

1、builder：抽象建造者---->为创建一个产品对象的各个部件指定抽象接口。

2、ConcreteBuilder:具体建造者---->实现Builder的接口（extents Builder）以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

3、Director：导演---->(告诉我们按照有什么顺讯构造对象)构造一个使用Builder接口的对象。（调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。）

4、Product：产品类---->表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终的接口。

public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}
//ConcreteBuilder  具体的建造者 实现Builder接口
public class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Man();
}
public void buildbody() {
person.setBody("建造男人的身体");
}
public void buildFoot() {
person.setFoot("建造男人的脚");
}
public void buildHead() {
person.setHead("建造男人的头");
}
public Person buildPerson() {
return person;
}
}
//Dirictor 决定构造的顺序  顺序不同会产生不同的对象
public class PersonDirector {
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
//Product  被构造的对象
public class Person {
private String head;
private String body;
private String foot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
}
public class Man extends Person {
}
//测试类Test
publ*c class Test{
public static void main(String[] ar*s) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System*out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}

示例可参考http://www.cnblogs.com/cbf4life/archive/2010/01/14/1647710.html

这个模式的核心在于，当构造对象构造过程顺序不同时，会产生不同的对象