1. 简介
主要关注点是“怎样创建对象？”，通过工厂创建对象，达到对象的创建和使用进行分离，降低系统耦合度。
创建型设计模式包括：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
(1) 单例模式
说明：为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，且该类能自行创建这个实例的一种模式。
- 懒汉式单例实现
package com.threadtest.designpattern;
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton(){
}
public static LazySingleton getInstance() {
if(instance == null) {
synchronized (LazySingleton.class) {
if(instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
- 饿汉式单例实现
package com.threadtest.designpattern;
public class HungrySingleton {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance() {
return instance;
}
}
(2) 原型模式
说明：通过简单、高效的方式创建对象。
1 ) 浅克隆
含义：实现 Cloneable 接口就可实现对象的浅克隆，不能对引用类型对象进行单独复制。
package com.threadtest.designpattern;
public class Realizetype implements Cloneable {
private String name;
public Realizetype(String name) {
this.name = name;
}
@Override
public Realizetype clone() {
try {
return (Realizetype) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2 ）深克隆
含义：通过序列化（Serialization）等方式来进行深度克隆。
package com.threadtest.designpattern;
import java.io.*;
public class DeepClonetype implements Serializable {
private String name;
public DeepClonetype(String name) {
this.name = name;
}
public DeepClonetype deepClone() throws Exception {
//将对象写入流中,
ByteArrayOutputStream bao = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bao);
oos.writeObject(this);
//将对象取出来
ByteArrayInputStream bi = new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bi);
return (DeepClonetype)ois.readObject();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
(3) 工厂方法模式
说明：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。
优点：
用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则
缺点：
每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
1 ) 产品接口代码
package com.threadtest.designpattern;
public interface Product {
void work();
}
2 ) 产品A代码
package com.threadtest.designpattern;
public class ProductA implements Product {
@Override
public void work() {
System.out.println("产品A进行工作!");
}
}
3 ) 产品B代码
package com.threadtest.designpattern;
public class ProductB implements Product {
@Override
public void work() {
System.out.println("产品B开始工作!");
}
}
4 ) 抽象工厂代码
package com.threadtest.designpattern;
public interface ProductFactory {
Product produce();
}
5 ）产品A工厂代码
package com.threadtest.designpattern;
public class ProductAFactory implements ProductFactory {
@Override
public Product produce() {
return new ProductA();
}
}
6 ) 产品B工厂代码
package com.threadtest.designpattern;
public class ProductBFactory implements ProductFactory {
@Override
public Product produce() {
return new ProductB();
}
}
7 ) 工厂执行代码
package com.threadtest.designpattern;
public class FactoryTest {
public static void main(String[] args) {
ProductFactory productFactory = new ProductAFactory();
Product productA = productFactory.produce();
productA.work();
productFactory = new ProductBFactory();
Product productB = productFactory.produce();
productB.work();
}
}
(4) 抽象工厂模式
说明：为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
满足条件:
系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。
优点
可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当增加一个新的产品族时不需要修改原代码，满足开闭原则。
缺点
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
(5) 建造者模式
说明：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示
优点：
各个具体的建造者相互独立，有利于系统的扩展。
客户端不必知道产品内部组成的细节，便于控制细节风险。
缺点：
产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，该模式会增加很多的建造者类。
网友评论