设计模式之：工厂模式

最新推荐文章于 2023-04-19 22:25:52 发布

原创最新推荐文章于 2023-04-19 22:25:52 发布 · 835 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#工厂模式 #设计模式

Java笔记专栏收录该内容

33 篇文章

订阅专栏

工厂模式

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，并且更具一般性。

情景模拟+代码实现

现在有两款汽车分别是奔驰，宝马。称之为“产品”：

abstract class Car {
    public Car() {
    }
}

public class BenzCar extends Car {
    public BenzCar() {
        System.out.println("奔驰汽车！");
    }
}

public class BMWCar extends Car {
    public BMWCar() {
        System.out.println("宝马汽车！");
    }
}

有了产品当然需要客户了。

1.无工厂模式

现在有“客户”需要使用汽车，但是没有工厂怎么办？
没办法，只能自己动手，丰衣足食。

public class Main {
    public static void main(String[] args) {
        Car car1 = new BenzCar();//制造奔驰汽车
        Car car2 = new BMWCar();//制造宝马汽车
    }
}

这里写图片描述

用户需要什么汽车，只需要new一下，然后自己制造就行了。（当然我们不用管他是怎么制造汽车的）
没有工厂时代的客户真的惨，需要什么汽车还要自己制造。~.~

2.简单工厂模式（Simple Factory）

然后有人发现制造汽车有利可图，建立了汽车工厂，生产汽车。然后向客户宣布：“你们给我下订单，你给我钱，我帮你们制造想要的汽车”！

public class SimpleFactory {
    /**
     * 1.生产奔驰汽车 2.生产宝马汽车
     *
     * @return
     */
    public Car create(int type) {
        switch (type) {
            case 1:
                return new BenzCar();
            case 2:
                return new BMWCar();
            default:
                break;
        }
        return null;
    }
}

客户喜闻乐见，这下买汽车可方便多了。只需要找到工厂下订单就行。

public class Main {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();//找到工厂
        factory.create(1);//下订单制造奔驰汽车
        factory.create(2);//下订单制造宝马汽车
    }
}

这里写图片描述

3.工厂方法模式（Factory Method）

这里写图片描述

汽车给人们带来极大的便利，然后汽车的需求量越来越大,汽车的类型也越来越多。
一个工厂无法制造多种类型的汽车，也已经无法满足当前的需求量了怎么办？
开“分厂”，每个分厂制造只制造一种汽车，大大提升了效率！

interface Factory {
    Car create();
}
//奔驰厂
public class BenzFactory implements Factory {
    @Override
    public Car create() {
        return new BenzCar();
    }
}
//宝马厂
public class BMWFactory implements Factory {
    @Override
    public Car create() {
        return new BMWCar();
    }
}

需要奔驰车的去奔驰厂，需要宝马车的去宝马厂。

public class Main {
    public static void main(String[] args) {
        Factory factory = new BenzFactory();
        factory.create();
        Factory factory1 = new BMWFactory();
        factory1.create();
    }
}

这里写图片描述

4.抽象工厂模式（Abstract Factory）

这里写图片描述

时代在进步，汽车制造也要进步。现在汽车需要装空调了！
但是空调也有两个品牌：海尔，美的。

public interface Aircondition {
}
public class HaierAircondition implements Aircondition {
    public HaierAircondition(){
        System.out.println("+装配海尔空调！");
    }
}
public class MeiderAircondition implements Aircondition{
    public MeiderAircondition() {
        System.out.println("+装配美的空调！");
    }
}

奔驰车装海尔空调，宝马汽车装美的空调！
工厂升级为可装空调的厂！

public interface AbstractFactory {
    Car car();

    Aircondition aircondition();
}
public class BenzHaierFactory implements AbstractFactory {

    @Override
    public Car car() {
        return new BenzCar();
    }

    @Override
    public Aircondition aircondition() {
        return new HaierAircondition();
    }
}

public class BMWMeiderFactory implements AbstractFactory {

    @Override
    public Car car() {
        return new BMWCar();
    }

    @Override
    public Aircondition aircondition() {
        return new MeiderAircondition();
    }
}

然而并不是每个客户都买的起空调车：

public class Main {
    public static void main(String[] args) {
  AbstractFactory factory = new BenzHaierFactory();
        factory.car();//购买奔驰汽车
        factory.aircondition();//带空调的

        AbstractFactory factory1 = new BMWMeiderFactory();
        factory1.car();//购买宝马汽车
        factory1.aircondition();//待美的空调的
        AbstractFactory factory2= new BMWMeiderFactory();
        factory2.car();//购买宝马汽车
        //factory1.aircondition();//不需要空调的
    }
}

这里写图片描述

5.比较：

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

总结

传统的无工厂模式下，客户调用方法（购买汽车），就必须知道方法的内部实现细节（汽车的制造工艺）。这对客户来说无疑是痛苦的。
而在简单工厂模式下，客户调用方法（购买汽车），只需要告诉方法类（工厂）自己需要哪种方法（汽车），无需知道方法的内部实现细节（汽车的制造工艺）。
工厂方法模式下，客户只需要找到相应的类（工厂），就能调用相应的方法（购买汽车），极大的方便了客户，提高了效率。然而其需要的类（工厂）根据需求是不断增加的，对应前期的代码投入(工厂投资，建厂)消耗是很大的，并不是完美的。
抽象工厂模式下，一个类运行有多个方法了（工厂可以同时汽车和空调），我们可以随意调用类中有关联的方法（汽车是否有空调）。虽然看似与工厂方法类似，但是其实现细节与内存还是有很大差异的。

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
工厂方法模式是继承自一个抽象类，子类去实现某一个工厂方法，将对象生产延迟到子类中。而抽象工厂模式，一般是实现一个抽象工厂的接口，由具体的工厂去实现相应的接口，可以这样说吧，抽象工厂模式是包含工厂方法模式的。