java设计模式总结篇--创建型模式

创建型模式中总共包含5个设计模式：

1.抽象工厂模式(Abstract Factory)

2.建造者模式(Builder)

3.工厂方法模式(Factory Method)

4.原型模式(Prototype)

5.单例模式(Singleton)

接下来分别进行总结。

抽象工厂模式

提供一个创建一系列或相关依赖对象的接口，而无需指定它们具体的类

实战例子：变更数据库方面的应用

首先定义一个行为的interface 里边包含了插入删除等行为举例 interface Idepartment

然后根据不同的数据库动作类来实现这个接口这样每种数据库都有了自己的实现插入删除等的方法

举例

 class accessDepartment implements Idepartment

再建立一个数据库的interface 里边包含了创建数据库的方法

举例 interface Ifactory

然后根据不同的数据库创建类来实现这个接口这样每种数据库都能够返回一个自己的实例

举例 class AccessFactory implements Ifactory

最后实现时

Ifactory factory = new AccessFactory ();

Idepartment id = factory.创建数据库();

这样如果有新的数据库接入就重复上边的步骤就能够使用新的数据库了  这就是抽象工厂的设计模式

好处是易于交换产品系列

由于具体工厂类只有在 Ifactory factory = new AccessFactory ();这个时候初始化过一次 这就使得改变一个引用的具体工厂变得容易 只需要改变初始化就可以

第二个好处就是它让具体的创建实例过程与客户端分离

客户端是用过它们的抽象接口操纵实例产品的具体类名也被具体工厂的实现分离不会出现在客户代码中

可以用反射+抽象工厂来解决数据库的变更问题这个是最好的

以上就是抽象工厂模式的总结

建造者模式

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

实战例子：画小人儿有头身体和脚 然后画一个胖小人和一个瘦小人

首先定义一个产品类 类中有添加部件的方法和显示部件的方法 Product

然后定义一个抽象建造者 abstract class Builder 里边有组装部件和返回结果的方法

然后实例化这个抽象的建造者  class ConcreteBuilderextends Builder

然后创建一个指挥者 class Director  里边有一个组装的过程 如 先放头部 然后放身体 最后放鞋子 这个方法的形参是Builder

实现的方法是

Director director =  new Director();

Builder b1 = new ConcreteBuilder();

director.组装过程(b1);

这样就只有一个指挥者来执行不同的建造者的建造过程

需要的话 就实例化一个自己的Builder,Builder可以有若干个 这就是建造者模式

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

简单来说  就是画一个小人 必须有画头 身体 和脚这么几个部分  我不关心怎么画出来  我只关心高矮胖瘦 不管是高是矮是胖是瘦 这个人必然会有头身体和脚这么几个部分

那么胖人 我就建立一个胖的builder

瘦子我就建立一个瘦builder  至于builder中怎么画出的人 我不管 只管画出的人的形状高矮胖瘦

建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配模式时适用的模式

以上就是建造者模式的总结

工厂方法模式

定义一个用于创建对象的接口让子类决定实例化哪一个类

工厂方法使一个类的实例化延迟到其子类

实战例子：大学生是活雷锋  社区志愿者也是活雷锋

首先定义一个interface Ifactory 里边包含一个创建雷锋的方法

然后定义一个大学生工厂Class 大学生工厂 implements Ifactory 实现里边接口的方法

然后定义一个志愿者工厂 class 志愿者工厂implements Ifactory 实现里边接口的方法

使用时

Ifactory factory =  new 大学生工厂();

雷锋 student = factory.创建雷锋();

好处是如果有一个新的群体是活雷锋的话 那么新建一个群体然后implements Ifactory

在建立factory的时候建立新的群体工厂就好了

这个方法解决了简单工厂模式中switch case过多的问题

以上就是工厂方法模式的总结

原型模式

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

原型模式其实就是从一个对象再创建另外一个可定制的对象而且不需要知道任何创建的细节

class Prototype implements Cloneable {
         publicPrototype clone(){
                   Prototypeprototype = null;
                   try{
                            prototype= (Prototype)super.clone();
                   }catch(CloneNotSupportedExceptione){
                            e.printStackTrace();
                   }
                   returnprototype;
         }
}

 

class ConcretePrototype extends Prototype{
         publicvoid show(){
                   System.out.println("原型模式实现类");
         }
}
 
public class Client {
         publicstatic void main(String[] args){
                   ConcretePrototypecp = new ConcretePrototype();
                   for(inti=0; i< 10; i++){
                            ConcretePrototypeclonecp = (ConcretePrototype)cp.clone();
                            clonecp.show();
                   }
         }
}

使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。

深拷贝与浅拷贝:

Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。

如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

public class Prototype implements Cloneable{
         privateArrayList list = new ArrayList();
         publicPrototype clone(){
                   Prototypeprototype = null;
                   try{
                            prototype= (Prototype)super.clone();
                            prototype.list= (ArrayList) this.list.clone();
                   }catch(CloneNotSupportedExceptione){
                            e.printStackTrace();
                   }
                   returnprototype;
         }
}

由于ArrayList不是基本类型，所以成员变量list，不会被拷贝，需要我们自己实现深拷贝，幸运的是java提供的大部分的容器类都实现了Cloneable接口。所以实现深拷贝并不是特别困难。

PS：深拷贝与浅拷贝问题中，会发生深拷贝的有java中的8中基本类型以及他们的封装类型，另外还有String类型。其余的都是浅拷贝。

以上就是原型模式的总结目前还没有使用到  感觉不是很深刻

单例模式

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

Class singleton
Private static singleton instance;
Private singleton(){
         //构造方法private 这就堵死了外界利用new创建此类实例的可能性
}
Public static singleton GetInstance(){
         If(instance== null ){
                   Instance= new singleton();
}
Return instance;
}

这里需要注意的是如果是多线程的话有可能导致创建多个实例这个时候需要添加一个lock

最好是双重lock

If(instance == null ){
Lock(lock.lock){
If(instance == null ){
                            Instance = new singleton();
}
}
}

比较多的使用在数据库的DAO上

以上就是单例模式的总结

总结：

所有的创建类模式本质上都是对对象的创建过程进行封装。