Design Pattern 3: Factory Method && Abstract Factory Pattern

最新推荐文章于 2024-05-05 21:29:41 发布

HackerDotCn

最新推荐文章于 2024-05-05 21:29:41 发布

阅读量203

点赞数

分类专栏： Design Pattern

本文链接：https://blog.csdn.net/hackerdotcn/article/details/78453345

版权

Design Pattern 专栏收录该内容

8 篇文章

订阅专栏

工厂方法

概念

定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory method lets a class defer instantiation to subclasses.

工厂方法类图

public abstract class Creator {
    /*
     * 创建一个产品对象,其输入参数类型可以自行设置
     * 通常为String、Enum、Class等，当然也可以为空
     */
    public abstract  T createProduct(Class c);
}

public class ConcreteCreator extends Creator {

    @Override
    public  T createProduct(Class c){
        Product product=null;
        try {
             product = (Product)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }       
        return (T)product;      
    }
}

public abstract class Product {

    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }

    //抽象方法1
    public abstract void method2();
}

public class ConcreteProduct1 extends Product {

    @Override
    public void method2() {
        //业务逻辑处理
    }
}

public class Client {

    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        /*
         * 继续业务处理
         */
    }
}

示例-女娲造人工厂方法
这里写图片描述

抽象工厂模式

概念

为创建一组相关或相互依赖的对象提供一个接口，且无需指定它们的具体类。
Provide an interface for creating families of related or dependant objects without specifying their concrete classes

抽象工厂模式类图

抽象工厂模式是工厂方法模式的升级版本，主要适用于有多种业务分类的情景。
代码中产品类与工厂方法中的类似，只是多了产品分类的概念，每种抽象产品下又分为不同的分类，其中每种具体工厂类负责生产一类的产品（继承于不同的抽象）。

public abstract class AbstractCreator {

    //创建A产品家族
    public abstract AbstractProductA createProductA();

    //创建B产品家族
    public abstract AbstractProductB createProductB();
}

public class Creator1 extends AbstractCreator {

    //只生产产品等级为1的A产品
    @Override
    public AbstractProductA createProductA() {  
        return new ProductA1();
    }

    //只生产产品等级为1的B产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class Creator2 extends AbstractCreator {

    //只生产产品等级为2的A产品
    @Override
    public AbstractProductA createProductA() {  
        return new ProductA2();
    }

    //只生产产品等级为2的B产品
    @Override
    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();

        /*
         * 然后在这里就可以为所欲为了...
         */

    }
}

参考：
《设计模式之禅》