前言：
本文仅作为第一次学习设计模式的参考和笔记。
初探工厂模式&抽象工厂模式：
工厂模式：Factory Pattern
原话：Define an interface for creating an object , but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
直译：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
1. 定义：父类为抽象接口，子类实例化具体需求。
2. 示例类图：
工厂模式通用类图
3. 示例代码：
//抽象产品类：
abstract class Product{
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void mehod2();
}
//具体产品类：
class ConcreteProduct1 extends Product{
public void mehod2(){
//业务逻辑处理
}
}
class ConcreteProduct2 extends Product{
public void mehod2(){
//业务逻辑处理
}
}
//抽象工厂类：
abstract class Creator{
/*
* 创建一个产品对象，其输入参数类型可以自行设置
* 通常为String、Enum、Class等，当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
class ConcreteCreator extends Creator{
public <T extends Product> T createProduct(Class<T> c){
Product product = null;
try{
product = (Product)Class.forName(c.getName()).newInstance();
}catch (Exception e){
//异常处理
}
return (T)product;
}
}
public class Client{
public static void main(String[] args){
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/*
* 继续业务处理
*/
}
}
4. 优点：
- 良好的封装性，代码结构清晰
- 扩展性优秀
- 屏蔽产品类
- 解耦框架
5. 使用场景：
- 生成对象的地方，增加工厂类进行管理
- 需要灵活的、可扩展的框架时，万物街对象
- 异构项目
- 测试驱动
6. 扩展：
- 简单工厂模式：仅一个工厂，一个模块，用静态方法。
interface Human{
//每个人种的皮肤都有相应的颜色
public void getColor();
//人类会说话
public void talk();
}
class HumanFactory {
static <T extends Human>T createHuman(Class<T> c){
//定义一个生产出的人种
Human human = null;
try{
//产生一个人种
human = (Human)Class.forName(c.getName()).newInstance();
}catch(Exception e){
//错误
}
return (T)human;
}
}
public class NvWa{
public static void main(String[] args){
Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.talk();
Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.talk();
Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
yellowHuman.getColor();
yellowHuman.talk();
}
}
- 多个工厂类：
//多工厂模式：
abstract class AbstractHumanFactory{
public abstract Human createHuman();
}
class BlackHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new BlackHuman();
}
}
class YellowHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new YellowHuman();
}
}
class WhiteHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new WhiteHuman();
}
}
public class NvWa{
public static void main(String[] args){
Human whiteHuman = (new WhiteHumanFactory()).createHuman();
whiteHuman.getColor();
whiteHuman.talk();
Human blackHuman = (new BlackHumanFactory()).createHuman();
blackHuman.getColor();
blackHuman.talk();
Human yellowHuman =(new YellowHumanFactory()).createHuman();
yellowHuman.getColor();
yellowHuman.talk();
}
}
- 替代单例模式：在内存中只产生一个对象
//替代单例模式：
//单例类：
class Singleton{
//不允许通过new产生一个对象
private Singleton(){
}
public void doSomeThing(){
//业务处理
}
}
//生产单例的工厂类：
class SingletonFactory{
private static Singleton singleton；
static{
try{
Class c1 = Class.forName(Singleton.class.getName());
//获得无参构造
Constructor constructor = c1.getDeclaredConstructor();
//设置无参构造是可访问的
constructor.setAccessible(true);
//产生一个实例对象
singleton = (Singleton)constructor.newInstance();
}catch(Exception e){
//异常处理
}
}
public static Singleton getSingleton(){
return singleton;
}
}
- 延迟初始化：一个对象结束后，不立即释放
//延迟加载的工厂类：
class ProductFactory{
private static final Map<String,Product>prMap = new HashMap();
public static synchronized Product createProduct(String type)throws Exception{
Product product = null;
//如果Map中已经有这个对象
if(prMap.containsKey(type)){
product = prMap.get(type);
}else{
if(type.equals("Product1")){
product = new ConcreteProduct1();
}else{
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put(type.product);
}
return product;
}
}
抽象工厂模式：Abstract Factory Pattern
原话：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
直译：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。
1. 定义：一组抽象的产品类，共同继承或实现一个抽象类或接口，实现具体细化区分。
2. 示例类图：
抽象工厂通用类图
3.示例代码：
//抽象产品类A
abstract class abstractProductA{
//每个产品共有的方法
public void shareMethod(){
}
//每个产品相同方法，不同实现
public abstract void doSomeThing();
}
//产品A1的实现类
class ProductA1 extends abstractProductA{
public void doSomeThing(){
//产品A1的实现方法
}
}
//产品A2的实现类
class ProductA2 extends abstractProductA{
public void doSomeThing(){
//产品A2的实现方法
}
}
//抽象产品类B
abstract class abstractProductB{
//每个产品共有的方法
public void shareMethod(){
}
//每个产品相同方法，不同实现
public abstract void doSomeThing();
}
//产品A1的实现类
class ProductB1 extends abstractProductB{
public void doSomeThing(){
//产品A1的实现方法
}
}
//产品A2的实现类
class ProductB2 extends abstractProductB{
public void doSomeThing(){
//产品A2的实现方法
}
}
//抽象工厂类
abstract class AbstractCreator{
//创建A产品家族
public abstract abstractProductA createProductA();
//创建B产品家族
public abstract abstractProductB createProductB();
}
//生产等级为1的实现类
class Creator1 extends AbstractCreator{
//只生产产品等级为1的A产品
public abstractProductA createProductA(){
return new ProductA1();
}
//只生产产品等级为1的B产品
public abstractProductB createProductB(){
return new ProductB1();
}
}
//生产等级为2的实现类
class Creator2 extends AbstractCreator{
//只生产产品等级为2的A产品
public abstractProductA createProductA(){
return new ProductA2();
}
//只生产产品等级为1的B产品
public abstractProductB createProductB(){
return new ProductB2();
}
}
//场景类：
public class Client {
public static void main(String[] args){
//定义出两个工厂
AbstractCreator creator1 = new Creator1();
AbstractCreator creator2 = new Creator2();
//产生A1对象
abstractProductA a1 = creator1.createProductA();
//产生A2对象
abstractProductA a2 = creator2.createProductA();
//产生B1对象
abstractProductB b1 = creator1.createProductB();
//产生B2对象
abstractProductB b2 = creator2.createProductB();
//...
}
}
4. 优点：
- 封装性：高层模块不用关心产品的实现类
- 产品族内的约束非公开
5. 缺点：
- 扩展很难，改动很大，违背开闭原则
6. 使用场景：
一个对象族。
7. 注意事项：
产品族扩展困难，产品等级扩展简单。
