小白必备工厂模式总结(简单工厂+工厂方法+抽象工厂)

其他设计模式介绍
Java23种设计模式之单例模式总结
Java23种设计模式之工厂模式总结(简单工厂+工厂方法+抽象工厂)
Java23种设计模式之原型模式总结(浅克隆和深克隆)
Java23中设计模式之建造者模式总结

介绍

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。

工厂模式可分为三类：

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

简单工厂模式可以看成是工厂模式的一种特例,二者可分为一类.

工厂模式的意义

将实例化的对象的代码提取出来，防到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护。

角色组成

工厂类角色： 这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

抽象产品角色： 它一般是具体产品继承的父类或者实现的接口。

具体产品角色： 工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

一、简单工厂模式

产品类

//产品类
public abstract class Phone {
    public abstract void make();
}

//华为
public class HWPhone extends Phone{
    @Override
    public void make() {
        System.out.println("生产华为手机");
    }
}
//小米
public class XMPhone extends Phone{
    @Override
    public void make() {
        System.out.println("生产小米手机");
    }
}

工厂类

//工厂类
public class PhoneFactory {

    public Phone makePhone(String name) {
        if ("xiaomi".equalsIgnoreCase(name)) {
            return new XMPhone();
        }else if ("huawei".equalsIgnoreCase(name)) {
            return new HWPhone();
        }else {
            return null;
        }
    }
}

测试

public class test {

    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        Phone xm = phoneFactory.makePhone("xiaomi");
        xm.make();

        Phone hw = phoneFactory.makePhone("huawei");
        hw.make();
    }
}

简单工厂模式总结

1. 优点： 好理解，易操作。
2. 缺点： 违反了设计模式的ocp原则，即对外开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

二、工厂方法模式

产品类

public abstract class Phone {
    public abstract void make();
}
//华为
public class HWPhone extends Phone {
    @Override
    public void make() {
        System.out.println("生产华为手机");
    }
}
//小米
public class XMPhone extends Phone {
    @Override
    public void make() {
        System.out.println("生产小米手机");
    }
}

工厂类

public interface FactoryPhone {
    Phone createPhone();
}
//华为
public class HWPhoneFactory implements FactoryPhone{

    @Override
    public Phone createPhone() {
        return new HWPhone();
    }
}
//小米
public class XMPhoneFactory implements FactoryPhone{

    @Override
    public Phone createPhone() {
        return new XMPhone();
    }
}

测试

public class test {

    public static void main(String[] args) {
        FactoryPhone xmPhoneFactory = new XMPhoneFactory();
        FactoryPhone hwPhoneFactory = new HWPhoneFactory();

        Phone xmphone = xmPhoneFactory.createPhone();
        xmphone.make();

        Phone hwphone = hwPhoneFactory.createPhone();
        hwphone.make();
    }
}

工厂方法模式总结

优点：

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

三、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

产品类

//手机
public abstract class Phone {
    public abstract void make();
}
//华为
public class HWPhone extends Phone {
    @Override
    public void make() {
        System.out.println("生产华为手机");
    }
}
//小米
public class XMPhone extends Phone {
    @Override
    public void make() {
        System.out.println("生产小米手机");
    }
}

//手环
public abstract class Bracelet {
    public abstract void makeBracelet();
}
//华为
public class HWBracelet extends Bracelet {

    @Override
    public void makeBracelet() {
        System.out.println("生产华为手环");
    }
}
//小米
public class XMBracelet extends Bracelet {

    @Override
    public void makeBracelet() {
        System.out.println("生产小米手环");
    }
}

工厂类

public interface FactoryPhone {
    Phone createPhone();
    Bracelet createBracelet();
}

//华为
public class HWPhoneFactory implements FactoryPhone {

    @Override
    public Phone createPhone() {
        return new HWPhone();
    }

    @Override
    public Bracelet createBracelet() {
        return new HWBracelet();
    }
}
//小米
public class XMPhoneFactory implements FactoryPhone {

    @Override
    public Phone createPhone() {
        return new XMPhone();
    }

    @Override
    public Bracelet createBracelet() {
        return new XMBracelet();
    }
}

测试

public class test {

    public static void main(String[] args) {
        FactoryPhone xmFactory = new XMPhoneFactory();
        FactoryPhone hwFactory = new HWPhoneFactory();
        //手机
        Phone xmphone = xmFactory.createPhone();
        xmphone.make();
        Phone hwphone = hwFactory.createPhone();
        hwphone.make();
        //手环
        Bracelet xmbracelet = xmFactory.createBracelet();
        xmbracelet.makeBracelet();
        Bracelet hwbracelet = hwFactory.createBracelet();
        hwbracelet.makeBracelet();
    }
}

抽象工厂模式总结

优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点： 产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

结论

工厂模式针对的是一个产品模式，而抽象工厂模式针对的多种产品模式

觉得博主写的不错的读者大大们，可以点赞关注和收藏哦，谢谢各位！

博主更多博客文章