23种设计模式之我见----创建型模式（1）

创建型模式：

         创建型模式抽象了实例化过程。他们帮助一个系统独立于如何创建、组合和表示他的那些对象。一个类创建型模式使用继承改变被实例化的类。而一个对象创建型模式将实例化委托给另一个对象。

1.工厂模式

这种模式没必要多讲，其实就是接口实现的问题，这种在项目开发中实在是太常见了

Animal

public interface Animal{

    public void Jiao();

};

Dog 

public class Dog implements Animal(){

    @override

    public void Jiao(){

    System.out.println("旺旺");

    }

}

Cat 

public class Cat implements Animal(){

      @override

    public void Jiao(){

    System.out.println("喵喵");

    }

}

people

public class people(){

  

    public getAnimal(){

    //如果在使用中需要添加一个dog，则在get方法中初始化一个dog

     Animal animal = new Dog();

    animal.Jiao();

}

}

2.抽象工厂

这里说一下抽象工厂和工厂模式的自己理解的区别：区别就是

抽象工厂无非就是把上面的People变成也有一个接口来实现，但是People会分为OldPeople和YoungPeople

People

public interface People{

    public Animal getAnimal();

};

OldPeople 

public class OldPeople implements People(){

    @override

    public Animal getAnimal(){

        Animal animal = new Dog();

        animal.Jiao();

    }

}

//YongPeople也是一样，但是年轻人可能就喜欢养猫了

3.建造者(Builder)模式

定义

将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

其实也很简单，想象一下我们小时候看的动画片，变形机器人，'我来组成头部'，就很好理解了，这个模式只是将这个动作进行了包装而已，所以外面只会看到‘变形’，而不知道是具体怎么变的

PersonBuilder 

public interface PersonBuilder {

void buildHead();

void buildBody();

void buildFoot();

Person buildPerson();

}

Product

public class Person {

private String head;

private String body;

private String foot;

//省略get set方法

}

ConcreteBuilder

public class ManBuilder implements PersonBuilder {

//这里强调是男人

Person person;

public ManBuilder() {

person = new Man();

}

public void buildbody() {

person.setBody("我来组成男人身体");

}

public void buildHead() {

person.setFoot("我来组成男人头部");

}

/**

其余的类似

**/

}

     Dirictor

     public class PersonDirector {

    //具体的构造在具体的类里面有实现

public Person constructPerson(PersonBuilder pb) {

pb.buildHead();

pb.buildBody();

pb.buildFoot();

return pb.buildPerson();

}

}

Test

public class Test{

public static void main(String[] args) {

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());

}

}

4原型模式

这个模式在一定的场景下是有很好的应用空间的，比如说：预先不知道要产生哪种实体，需要在运行期动态的进行加载，那这时候原型可能就是比较好的选择，比如有很多颜色的气球，但是只有在程序运行到一段时间的时候才知道是哪种颜色，这时候我们就需要原型模式。

原型模式其实也就是运用clone过程的模式，当然clone你可以自己写，也可以使用java object自带的clone（浅复制），也可以直接写到流里面，然后再读出来，这就是（深复制），即 利用串行化来做深复制：

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

，深浅复制可以自己查阅，基本原理就是上述的两种。

（深复制是复制新的一个对象，浅复制是复制一个对象，但是属性都是引用原对象）

5单例模式

最经典的模式之一，也是各种面试最常见的模式。

单例模式有以下特点：
　　 1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

public class Singleton {

    private static Singleton uniqueInstance = null;

 

    private Singleton() {

       // Exists only to defeat instantiation.

    }

 

    public static Singleton getInstance() {

       if (uniqueInstance == null) {

           uniqueInstance = new Singleton();

       }

       return uniqueInstance;

    }

    // Other methods...

}

        但是说实话个人感觉这个例子其实有很大的局限性，首先这个例子不是线程安全的，在并发情况下还是有可能会出现多个实例。

所以，有了下面的线程安全的单例

1.饿汉式：

        public class SingleTon{

        private SingleTon(){};

        private static final SingleTon singleTon = new SingleTon();

        public getSingleTon(){

    return this.singleTon;

}

}

2.懒汉式

     public class SingleTon{

        private SingleTon(){};

        //注意，这里并没有final

        private static SingleTon singleTon = null;

        public synchronized  SingleTon getSingleTon(){

            if(singleTon==null){

                singleTon = new SIngleTon();

            }

        return singleTon;

        }

}

但是，我们注意，这是一个效率极其低下的单例，因为其在获得实例的时候是有一个同步锁的，无疑会导致成为瓶颈所在，所以，比较好的做法是，这是我认为一个比较好的实现单例的方法：

public class SingleTon{

   private SingleTon() {

}

   private static Object lock=new Object();

    //注意，这里并没有final

    private static SingleTon singleTon = null;

    public static SingleTon getSingleTon(){

       if(singleTon!=null){

            return singleTon;

       }else{

        synchronized(lock){

        if(singleTon==null){

        singleTon = new SingleTon();

        }

        }

}

    return singleTon;

    }

}