2_工厂设计_工厂方法和抽象工厂

本文介绍: 工厂设计之工厂方法和抽象工厂，详细说明和使用案例使用场景说明

工厂设计模式-工厂方法

1.概念

工厂方法模式(Fatory Method Pattern ) 是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节。

2.案例说明和分析

2.1 定义一个创建对象的接口

public interface ICourse {
    void record(); //录制抽象功能
}
public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制Java课程");
    }
}
public class PythonCourse implements ICourse {
    public void record() {
        System.out.println("录制Python课程");
    }
}

/** 工厂模型 */
public interface ICourseFactory {
    ICourse create();
}

2.2 定义接口和实现类

public class JavaCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new JavaCourse();
    }
}
public class PythonCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new PythonCourse();
    }
}

2.3实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

public class FactoryMethodTest {
    public static void main(String[] args) {
        ICourseFactory factory = new PythonCourseFactory();
        ICourse course = factory.create();
        course.record();
        factory = new JavaCourseFactory();
        course = factory.create();
        course.record();
    }
}

2.4 类图

在这里插入图片描述

3.总结

使用步骤：

创建一个接口A(实现抽象接口功能名write() )和实现类AImpl(实现逻辑代码:writ(){…})。

在创建创建一个接口工厂B(实现抽象功能返回接口A对象: creatA();)和实现类BImpl(实现逻辑返回AImpl实现类对象:createA(){ return new AImpl();})。

创建一个调用类 -> B b = new BImpl(); A a = b.createA(); a.write();

代码实现：

public interface A {
    void write(); 
}
//业务实现逻辑
public class AImpl implements A {
    public void write() {
        //不依赖于产品类实例如何被创建、实现等细节 
        System.out.println("写Java作业");
    }
}

//-------------------------------
public interface B {
     A createA();
}
public class BImpl implements B {
    public A createA() {
        //创建对象需要大量重复的代码
        return new AImpl(); //一个类通过其子类来指定创建哪个对象；
    }
}

B b = new BImpl();
A a = b.createA();
a.write();

为什么要使用工厂方法了啊？解决什么问题。

创建对象需要大量重复的代码；
客户端(应用层)不依赖于产品类实例如何被创建、实现等细节；
一个类通过其子类来指定创建哪个对象；

工厂方法也有缺点

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度

工厂设计模式-抽象工厂

1.案例说明和分析

//步骤1：创建接口和实现类
public interface ICourse {
    /* 录制视频 */
    void record();
}
public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制Java课程");
    }
}
//多个....


// 步骤2： 创建抽象工厂类，并创建抽象方法返回实现类对象(接口对象)
public abstract class CourseFactory {
    public void init(){
        System.out.println("初始化基础数据");
    }
    protected abstract ICourse createCourse();
    
    //(都属于同一组的产品(小米空调，小米电视，小米手机)之间有一些联系) 多个....
}



//步骤3：继承抽象类工厂并实现抽象方法(创建实现类并返回)
public class JavaCourseFactory extends CourseFactory {
    public ICourse createCourse() {
        super.init();
        return new JavaCourse();
    }
}
//多个....


// 步骤4：创建继承抽象类的实例对象，并调用实现类中的业务逻辑方法
public class AbstractFactoryTest {
    public static void main(String[] args) {
        //一起使用创建对象需要大量重复的代码,这里就解决了。
        CourseFactory factory = new JavaCourseFactory();
        factory.createCourse().record();
        //多个...
    }
}