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;
}
}