一、Factory(工厂)
描述：将相似接口或类的实例化统一处理，对于构造函数较复杂且多个类之间又有联系的可以采用该模式
好处：a、封装对象创建的细节，减少相干性；b、有利于同类对象的统一创建和管理；
例子：
1、简单工厂方法
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
2、抽象工厂模式
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
使用抽象工厂而不使用简单工厂原因是当创建的对象变复杂，并且创建的对象间还有联系，如上述例子。
二、Prototype(原形)
tips：深拷贝和浅拷贝
浅拷贝：指拷贝引用地址，如 String s1 = "hello"; String s2 = s1;
深拷贝：拷贝具体内容，如调用Object.clone()方法
描述：通过给出一个原型对象来指明所要创建的对象类型，然后用复制这个原型对象的办法创建出更多的同类型对象
好处：a、允许动态的增加或减少产品类，对整个结构没影响；b、不需要严格的等级结构(如工厂模式)，适合任何结构对象
以勺子为例：
public abstract class AbstractSpoon implements Cloneable
{
String spoonName;
public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
public String getSpoonName() {return this.spoonName;}
public Object clone()
{
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println("AbstractSpoon is not Cloneable");
}
return object;
}
}
有两个具体实现(ConcretePrototype):
public class SoupSpoon extends AbstractSpoon
{
public SoupSpoon()
{
setSpoonName("Soup Spoon");
}
}
public class SaladSpoon extends AbstractSpoon
{
public SaladSpoon()
{
setSpoonName("Salad Spoon");
}
}
调用Prototype模式很简单:
AbstractSpoon aspoon = new SoupSpoon();
AbstractSpoon bspoon = new SaladSpoon();
拷贝就
AbstractSpoon spoon = aspoon.clone();
三、Builder(建造者)
描述：将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.
好处：将创建复杂对象的过程和它的部件解耦
例子：
需要一个接口,它定义如何创建复杂对象的各个部件:
public interface Builder {
//创建部件A 比如创建汽车车轮
void buildPartA();
//创建部件B 比如创建汽车方向盘
void buildPartB();
//创建部件C 比如创建汽车发动机
void buildPartC();
//返回最后组装成品结果 (返回最后装配好的汽车)
//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
//从而实现了解耦过程和部件
Product getResult();
}
用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容是如何将部件最后组装成成品:
public class Director {
private Builder builder;
public Director( Builder builder ) {
this.builder = builder;
}
// 将部件partA partB partC最后组成复杂对象
//这里是将车轮 方向盘和发动机组装成汽车的过程
public void construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西;
提供一个可以重新获取产品的接口:
public class ConcreteBuilder implements Builder {
Part partA, partB, partC;
public void buildPartA() {
//这里是具体如何构建partA的代码
};
public void buildPartB() {
//这里是具体如何构建partB的代码
};
public void buildPartC() {
//这里是具体如何构建partB的代码
};
public Product getResult() {
//返回最后组装成品结果
};
}
复杂对象:产品Product:
public interface Product { }
复杂对象的部件:
public interface Part { }
我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );
director.construct();
Product product = builder.getResult();
四、Singleton(单例)
描述：保证在Java应用程序中，一个类Class只有一个实例存在
好处：保证该类的唯一性,节省内存、有利于JAVA垃圾回收
1、饿汉式
class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance() {
return instance;
}
}
2、懒汉式
class Singleton {
private static Singleton instance=null;
private Singleton(){}
static Singleton getInstance() {
if(instance==null)
instance=new Singleton();
return instance;
}
}
饿汉式是线程安全的，懒汉式是线程不安全的，如果要考虑线程，可以同步代码块也可以同步方法，同步代码块是最好的方法