抽象工厂模式【设计模式】

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是指提供一个 创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。

使用场景

• 客户端不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象（属于同一产品组）一起使用创建对象需要大量重复的代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

缺点

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
• 增加了系统的抽象性和理解难度

优点

• 具体产品在应用层代码隔离，无须关心创建细节
• 将一个系列的产品族统一到一起创建

课程

课程类图

课程代码实现

1.创建课程接口及实现课程子类

public interface Course {
    /**
     * 录制课程
     */
    void record();
}

public class JavaCourse implements Course {

    @Override
    public void record() {
        System.out.println("录制Java课程");
    }
}

public class PythonCourse implements Course {

    @Override
    public void record() {
        System.out.println("录制Python课程");
    }
}

2.创建笔记接口及实现子类

public interface Note {
    /**
     * 编写笔记
     */
    void edit();
}

public class JavaNote implements Note {
    @Override
    public void edit() {
        System.out.println("编写Java笔记");
    }
}

public class PythonNote implements Note{
    @Override
    public void edit() {
        System.out.println("编写python笔记");
    }
}

3.创建回放接口及子类

public interface Video {
    /**
     * 录制
     */
    void record();
}

public class JavaVideo implements Video{
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}

public class PythonVideo implements Video{
    @Override
    public void record() {
        System.out.println("录制python视频");
    }
}

4.创建抽象工厂组装产品

public abstract class CourseFactory {
    public void init(){
        System.out.println("初始化基础数据的方法");
    }

    /**
     * 创建笔记，并交由子类实现
     * @return
     */
    protected abstract Note createNote();

    /**
     * 创建回放，由子类实现
     * @return
     */
    protected abstract Video createVideo();
}

5.创建课程工厂

//Java课程工厂
public class JavaCourseFactory extends CourseFactory{
    @Override
    protected Note createNote() {
        super.init();
        return new JavaNote();
    }

    @Override
    protected Video createVideo() {
        super.init();
        return new JavaVideo();
    }
}

//python课程工厂
public class PythonCourseFactory extends CourseFactory{

    @Override
    protected Note createNote() {
        super.init();
        return new PythonNote();
    }

    @Override
    protected Video createVideo() {
        super.init();
        return new PythonVideo();
    }
}

6.测试

public class Test {
    public static void main(String[] args) {
        CourseFactory factory = new JavaCourseFactory();
        factory.createNote().edit();
        factory.createVideo().record();
    }
}
//测试结果
初始化基础数据的方法
编写Java笔记
初始化基础数据的方法
录制Java视频

支付

也可以使用策略模式实现

类图

代码实现

1.创建支付接口

public interface Pay {
    /**
     * 支付场景
     */
    void pay();
}

2.创建支付宝支付方式

public class Alipay implements Pay{
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}

3.创建微信支付方式

public class WechatPay implements Pay{
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}

4.计算金额

public class Compute {
    void compute(){
        System.out.println("计算订单价格");
    }
}

5.创建抽象工厂

public abstract class IPayFactory {
    public static final Compute compute = new Compute();
    public void init(){
        //支付前调用计算金额方法
        compute.compute();
    }
    /**
     *创建支付方式
     * @return
     */
   protected abstract Pay create();
}

6.创建支付宝支付工厂

public class AlipayFactory extends IPayFactory{
    /**
     * 调用计算订单方法和创建支付宝支付
     * @return
     */
    @Override
    protected Pay create() {
        super.init();
        return new Alipay();
    }
}

7.创建微信支付工厂

public class WechatPayFactory extends IPayFactory{
    @Override
    protected Pay create() {
        super.init();
        return new WechatPay();
    }
}

8.测试

public class Test {
    public static void main(String[] args) {
        IPayFactory factory = new AlipayFactory();
        Pay pay = factory.create();
        pay.pay();
        IPayFactory payFactory = new WechatPayFactory();
        Pay pay1 = payFactory.create();
        pay1.pay();
    }
}
//测试结果
计算订单价格
支付宝支付
计算订单价格
微信支付