工厂模式总结——三个工厂

最新推荐文章于 2022-10-24 17:39:54 发布

知识焦虑症患者

最新推荐文章于 2022-10-24 17:39:54 发布

阅读量431

点赞数

文章标签： java 开发语言设计模式

本文链接：https://blog.csdn.net/weixin_43301424/article/details/127023976

版权

在创建型模式中，工厂模式是我们日常使用最为频繁的设计模式之一。工厂模式可细分为简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式

模式简介

简单工厂模式：根据参数返回不同类的实例，这些类通常具有共同的父类。

简单工厂模式包括三个角色：

工厂 (Factory)：用于创建所需产品，提供静态工厂方法，返回抽象产品类型 Product；
抽象产品 (Product)：是工厂创建的所有对象的父类，封装了各种共有方法；
具体产品 (ConcreateProduct)：工厂创建目标，继承抽象产品，实现了抽象产品的抽象方法。

应用实例

工厂——FruitFactory

public class FruitFactory {

    public static Object createFruit(String clazzName)  throws Exception{
        Object obj = null;
        if (clazzName.equals(Apple.class.getName())){
            obj = new Apple();
        } else if (clazzName.equals(Strawberry.class.getName())){
            obj = new Strawberry();
        } else if (clazzName.equals(Banana.class.getName())){
            obj = new Banana();
        } else {
            throw new ClassNotFoundException("没有找到该类");
        }
        return obj;
    }

    //升级简化版
    /*public static Object create(String clazzName) throws Exception{
        Object obj = null;
        Class clazz = Class.forName(clazzName);
        if (clazz.isAssignableFrom(Fruit.class)){
            obj = clazz.newInstance();
        } else {
            throw new ClassNotFoundException("没有找到该类");
        }
        return obj;
    }*/
}

抽象产品——Fruit

public abstract class Fruit {
    public abstract void getInfo();
}

具体产品——Apple、Banana、Strawberry

Apple

public class Apple extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("这是一个砸中牛顿脑袋的苹果");
    }
}

Banana

public class Banana extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("这是一根让犹太人致富的香蕉");
    }
}

Strawberry

public class Strawberry extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("这是一颗甜到你心里的草莓");
    }
}

客户端

public class MainTest {
    public static void main(String[] args) throws Exception {
        //要个苹果
        Apple apple = (Apple) FruitFactory.createFruit(Apple.class.getName());
        apple.getInfo();
        //要颗草莓
        Strawberry strawberry = (Strawberry) FruitFactory.createFruit(Strawberry.class.getName());
        strawberry.getInfo();
        //要根香蕉
        Banana banana = (Banana) FruitFactory.createFruit(Banana.class.getName());
        banana.getInfo();
    }
}

模式总结

优点：实现简单，屏蔽了对象创建过程，实现了对象创建和使用的分离。

缺点：集中了所有产品创建逻辑，职责过重；扩展困难，一旦添加类需修改源码；使用静态工厂方法，工厂角色无法形成继承结构。

使用场景：工厂负责创建对象较少。

工厂方法模式

模式简介

工厂方法模式：定义了一个用于创建对象的接口，但是让子类决定将哪个类实例化。工厂方法让一个类的实例化延迟到了子类。

工厂方法模式在简单工厂模式的基础上，引入了抽象工厂，将具体产品的创建延迟到了具体工厂，克服了简单工厂模式职责过重的缺点。

工厂方法模式包括了 4 个角色：

抽象工厂（AbstractFactory）：定义了抽象工厂方法，用于返回一个产品，具体返回哪类产品由具体工厂决定。
抽象产品（AbstractProduct）：是所有具体产品的公共父类，定义了产品的接口。
具体工厂（ConcreteFactory）：是抽象工厂的子类，实现了抽象工厂的工厂方法，返回一个具体产品。
具体产品（ConcreteProduct）：实现了抽象产品接口，由具体工厂创建。

应用实例

抽象工厂——FruitFactory

public abstract class FruitFactory {
    public abstract Fruit createFruit();
}

抽象产品——Fruit

public abstract class Fruit {
    public abstract void getInfo();
}

具体工厂——AppleFactory、BananaFactory、StrawberryFactory

AppleFactory

public class AppleFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

BananaFactory

public class BananaFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Banana();
    }
}

StrawberryFactory

public class StrawberryFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Strawberry();
    }
}

具体产品——Apple、Banana、Strawberry

Apple

public class Apple extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一个砸中牛顿脑袋的苹果");
    }
}

Banana

public class Banana extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一根让犹太人致富的香蕉");
    }
}

Strawberry

public class Strawberry extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一颗甜到你心里的草莓");
    }
}

客户端

public class MainTest {
    public static void main(String[] args) throws Exception {
        FruitFactory factory = null;
        //要个苹果
        factory = new AppleFactory();
        Fruit apple = factory.createFruit();
        apple.getInfo();
        //要颗草莓
        factory = new StrawberryFactory();
        Fruit strawberry = factory.createFruit();
        strawberry.getInfo();
        //要根香蕉
        factory = new BananaFactory();
        Fruit banana = factory.createFruit();
        banana.getInfo();
    }
}

模式总结

优点

隐藏了对象创建细节，用户创建对象时无需知道具体类名，只需知道相应的工厂类即可创建相应类对象。
在系统中添加新的产品时不会对现有代码产生影响，具有良好的扩展性，符合开闭原则。

缺点

每个产品需要添加对应的具体工厂类，类的数量因此成对增加，增加了系统复杂性和性能消耗。
引入了抽象层，增加了系统的抽象性和理解难度。

使用场景

客户端不需要知道它所需创建的类对象的类名；
抽象类通过子类来指定创建具体哪个类的对象。

抽象工厂模式

模式简介

抽象工厂：提供一个创建一系列相关或相关以来对象的接口，从而无需指定他们具体的类。

两个概念

产品等级结构：即产品的继承结构，水果是个抽象类，其子类包括苹果、香蕉、草莓，则抽象类与具体类之间构成了一个产品等级结构。

产品族：在抽象工厂模式中，产品族是同一个工厂生产的不同产品等级结构中的一组产品。例如当前有两个生产水果的工厂A和B都生产水果苹果、香蕉、草莓，则工厂A生产的苹果、香蕉、草莓构成一个产品族。

抽象工厂模式与工厂方法模式的区别在于，工厂方法模式针对的是一个产品等级结构，每一个具体工厂只能创建一个产品；而抽象工厂模式针对的是多个产品等级结构，其每个具体工厂负责创建一族的产品。

抽象工厂模式包括了 4 个角色：

抽象工厂（AbstractFactory）：声明了一组用于创建一族产品的方法，每个方法对应一种产品。
抽象产品（AbstractProduct）：为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
具体工厂（ConcreteFactory）：实现了抽象工厂中声明的创建产品的方法，生成了一组具体产品，这些具体产品构成了一个产品族，每个产品位于某个产品等级结构中。
具体产品（ConcreteProduct）：实现了抽象产品接口，由具体工厂创建。

应用实例

抽象工厂——FruitFactory

public abstract class FruitFactory {

    public abstract Fruit createApple();

    public abstract Fruit createBanana();

    public abstract Fruit createStrawberry();

}

抽象产品

public abstract class Fruit {
    public abstract void getInfo();
}

具体工厂——FruitFactoryA、FruitFactoryB

FruitFactoryA

public class FruitFactoryA extends FruitFactory {
    
    @Override
    public Fruit createApple() {
        return new AppleA();
    }

    @Override
    public Fruit createBanana() {
        return new BananaA();
    }

    @Override
    public Fruit createStrawberry() {
        return new StrawberryA();
    }
}

FruitFactoryB

public class FruitFactoryB extends FruitFactory {

    @Override
    public Fruit createApple() {
        return new AppleB();
    }

    @Override
    public Fruit createBanana() {
        return new BananaB();
    }

    @Override
    public Fruit createStrawberry() {
        return new StrawberryB();
    }
}

具体产品AppleA、AppleB、BananaA、BananaB、StrawberryA、StrawberryB

AppleA

public class AppleA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一个砸中牛顿脑袋的苹果，由工厂A生产");
    }
}

AppleB

public class AppleB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一个砸中牛顿脑袋的苹果，由工厂B生产");
    }
}

BananaA

public class BananaA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一根让犹太人致富的香蕉，由工厂A生产");
    }
}

BananaB

public class BananaB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一根让犹太人致富的香蕉，由工厂B生产");
    }
}

StrawberryA

public class StrawberryA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一颗甜到你心里的草莓，由工厂A生产");
    }
}

StrawberryB

public class StrawberryB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("这是一颗甜到你心里的草莓，由工厂B生产");
    }
}

客户端

public class MainTest {
    public static void main(String[] args) throws Exception {
        FruitFactory factoryA = new FruitFactoryA();
        FruitFactory factoryB = new FruitFactoryA();
        //要个苹果
        Fruit appleA = factoryA.createApple();
        appleA.getInfo();
        Fruit appleB = factoryB.createApple();
        appleB.getInfo();
        //要颗草莓
        Fruit strawberryA = factoryA.createStrawberry();
        strawberryA.getInfo();
        Fruit strawberryB = factoryA.createStrawberry();
        strawberryB.getInfo();
        //要根香蕉
        Fruit bananaA = factoryA.createStrawberry();
        bananaA.getInfo();
        Fruit bananaB = factoryA.createStrawberry();
        bananaB.getInfo();
    }
}

模式总结

优点

隔离了具体类的生成，更换一个具体工厂就可以在某种程度上改变整个软件系统行为。
当一个产品族的多个对象被设计成一起工作时，能够保证客户始终只是用同一个产品族中的对象。
添加新的产品无需修改已有代码，符合开闭原则。

缺点

添加新的产品等级结构需要对原有系统进行较大修改，违背了开闭原则。

使用场景

系统有过个产品族，而每次使用只使用其中一个产品族；
产品等级结构稳定，设计完成后不会对系统增加或删除的产品等级结构。

工厂模式总结

简单工厂模式隐藏了对象创建细节，将象创建过程与系统业务分离，只需传入响应参数即可获得相应对象，缺点是职责过重。
工厂方法模式引入了抽象工厂，克服了简单工厂模式的缺点，将具体对象创建延迟到了子类且可以灵活扩展，但一定程度上造成了系统的类数量膨胀，损耗系统性能。
抽象工厂模式在工厂方法模式的基础上进一步扩展，每个具体工厂负责创建多个产品等级结构，减小了工厂方法模式造成的类膨胀问题，提供了系统效率。但是，抽象工厂模式存在开闭原则的倾向性，适用于只需扩展产品族，而产品登记结构稳定的系统。