概念
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
简单工厂模式
简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创造出哪一种产品的实例类，但它不属于GOF23种设计模式。
1.创建接口
public interface ICourse {
public void record();
}
2.创建接口实现类
public class JavaCourse implements ICourse{
@Override
public void record() {
System.out.println("Java 语言");
}
}
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("pythod语言");
}
}
3.创建工厂类
public class SimpleFactory {
public ICourse getCourse(String name){
if("java".equals(name)){
return new JavaCourse();
}
if("python".equals(name)){
return new PythonCourse();
}else{
return null;
}
}
}
4.创建测试类
public class FactoryTest {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
ICourse course = simpleFactory.getCourse("java");
course.record();
}
}
运行结果：
简单工厂适用于工厂类负责创建对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心
缺点
- 工厂类的职责相对过重，不易于扩展过于复杂的产品结构
工厂方法模式
工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。
1.创建工厂接口
public interface ICourseFactory {
public ICourse create();
}
2.创建实现接口的工厂类
public class JavaCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new JavaCourse();
}
}
public class PythonCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new PythonCourse();
}
}
3.测试类
public class FactoryMethodTest {
public static void main(String[] args) {
ICourseFactory iCourseFactory=new JavaCourseFactory();
ICourse icourse=iCourseFactory.create();
icourse.record();
}
}
运行结果：
在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节
缺点
- 类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度
抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
1.创建产品接口
public interface IAirConditioning {
public void cold();
}
public interface IPhone {
public void call();
}
2.创建产品
public class GreePhone implements IPhone {
@Override
public void call() {
System.out.println("格力电话");
}
}
public class GreeAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("好空调，格力造");
}
}
public class MideaPhone implements IPhone{
@Override
public void call() {
System.out.println("美的电话");
}
}
public class MideaAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("美的空调-精彩生活由我创造");
}
}
3.创建抽象工厂
public abstract class AbstractFactory {
public void init(){
System.out.println("开始。。。");
}
protected abstract IPhone createPhone();
protected abstract IAirConditioning createAirConditioning();
}
4.创建具体工厂
public class MideaFactory extends AbstractFactory{
@Override
protected IPhone createPhone() {
return new MideaPhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new MideaAirConditioning();
}
}
public class GreeFactory extends AbstractFactory {
@Override
protected IPhone createPhone() {
return new GreePhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new GreeAirConditioning();
}
}
4.测试
public class AbstractFactoryTest {
public static void main(String[] args) {
GreeFactory greeFactory=new GreeFactory();
greeFactory.createAirConditioning().cold();
}
}
运行结果：
缺点
- 规定了所有可能被创建的产品集合，产品族如果发生改变，那么从抽象工厂到具体工厂都要发生调整，不符合开闭原则
- 增加了系统的抽象性和理解难度
开闭原则：一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。