BlogJava-虚幻世界-文章分类-设计模式

单例模式（singleton）构建模式

海峰 — Thu, 15 Mar 2012 15:10:00 GMT

定义
    在java程序中只有一个Class实例对象。
为何试用
    比如类似于连接数据库这样的操作，只需要一个连接对象。这样可以节省内存，也有利于垃圾回收（GC）
    也可以状态化比如说论坛上的访问计数器。
    也可以做无状态的工具性质的功能。
例子：

public class Singleton {

　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {
　　　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}

使用Singleton.getInstance()可以访问单态类。

但是值得注意的是在分布式的情况下一定要注意，不同的对象都去装在单例对象。

海峰 2012-03-15 23:10 发表评论

建造者模式（builder）构建模式

海峰 — Thu, 15 Mar 2012 14:51:00 GMT

定义
    将一个对象的复杂构建过程和表示分离开
含义
    就是将对象的复杂的构建过程分离开，已达到解耦过程和部件。
为何试用
    例如你需要加工手机，如果每个型号的手机都有一个加工组装厂，会不会感觉很多余呀。你只需要建造一个组装厂即可，安装的过程吗肯定都是一样的。所以你给我什么型号的手机部件我就给你组装什么型号的手机。这样将手机的组装和手机的部件有效的分离开减少耦合。而且有利于维护，比如说有一天手机天线不需要外置了，都已经内置了。那只要告诉组装厂减去装外置天线的哪一步就够了。

例子:

public interface Builder {

　　//创建部件A　
　　void buildPartA();
　　//创建部件B
　　void buildPartB();

　　//返回最后组装成品结果
　　//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
　　//从而实现了解耦过程和部件
　　Product getResult();

}

public class Director {

　　private Builder builder;

　　public Director( Builder builder ) {
　　　　this.builder = builder;
　　}
　　// 将部件partA partB最后组成复杂对象
　　public void construct() {
　　　　builder.buildPartA();
　　　　builder.buildPartB();

　　}

public class ConcreteBuilder implements Builder {

　　Part partA, partB;
　　public void buildPartA() {
　　　　//这里是具体如何构建partA的代码

　　};
　　public void buildPartB() {
　　　　//这里是具体如何构建partB的代码
　　};
　　 public Product getResult() {
　　　　//返回最后组装成品结果
　　};

}

我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );
director.construct();
Product product = builder.getResult();

海峰 2012-03-15 22:51 发表评论

原型模式（prototype）构建模式

海峰 — Wed, 14 Mar 2012 14:48:00 GMT

定义
    用原型实例制定穿件对象的类型，并拷贝这个原型来创建对象。
含义
    一个操作或是一个对象在创建一个制定的对象的时候，无需知道该对象的创建过程，根据所给的原型对象拷贝出所需的对象。
使用
    因为java语言中有clone()方法，所以实现起来很容易。
例子

    public abstract class AbstractPrototype implements Cloneable
    {
　　    String name;

　　    public void setName(String Name) {this.name = name;}
　　    public String getName() {return this.name;}

　    　public Object clone()
　　    {
　　　    　Object object = null;
　　　　    try {
　　　　　　    object = super.clone();
　　　　    } catch (CloneNotSupportedException exception) {
　　　　　　    System.err.println("AbstractPrototype is not Cloneable");
　　　　    }
　　　　    return object;
　　    }
    }

    public class SoupPrototype extends AbstractPrototype
    {
　　    public SoupPrototype()
　　    {
　　　    　setName("Soup Prototype");
　　    }
    }

    public class SaladPrototype extends AbstractPrototype
    {
　    　public SaladPrototype()
　　    {
　　　    　setName("Salad Prototype");
　　    }
    }

调用就很简单了
    AbstractPrototype soup = new SoupPrototype();
    AbstractPrototype salad = new SaladPrototype();
    SoupPrototype soupClone = (SoupPrototype)soup.clone();
    SaladPrototype saladClone = (SaladPrototype)salad.clone();

这两个克隆出来的对象就是你想要的了是不是很简单呀。

海峰 2012-03-14 22:48 发表评论

工厂模式（factory）构建模式

海峰 — Thu, 01 Mar 2012 03:45:00 GMT

      写东西的能力有限，希望可以谅解。

工厂模式
      定义：提供创建对象的接口
为何使用：如果在一个项目中你需要new很多的实体，恰好这个实体new的过程很是复杂，而且有一天你的PM说在这个new的工程中加一个级别的过滤吧。
               你会突然发现你的工作量怎么那么大呢！如果当时用到了工厂你就会发现原来加这个需求是这么的简单。而且在new的过程出现错误的几率将
               大大的降低了。你的代码也将会非常整洁。
      实例：（直接上代码，发现弄图片是如此的麻烦！）
        //这只是一个小例子，会根据给出的颜色来给出具体的实例

public class WorkFactory {

         public static Work getWork(String color){
          return color.equals("black")?new BlackWork():new WhiteWork();
         }
        }

抽象工厂
       定义：如果工厂是生产实例的，那抽象工厂就是一个整个工厂的架构没有具体的实现
为何使用：比如人家想用你的工厂，但是你又不想让人家看到你工厂里面具体的工作，并且你还要告诉他你工厂可能干什么。这时候你就可以给他看你的抽象的工厂
                而不是真正再生产的工厂了。而且利于扩展，比如又让你建一个工厂和上一个在实现上有区别但是还是那几个方法。这样你利用抽象工厂很快就可以搭建
                这另一个工厂了。
        实例：

public abstract class AbstractFactory {

             public abstract Work getWork() throws Exception;
             public abstract Study getStudy() throws Exception;
            }

海峰 2012-03-01 11:45 发表评论