设计模式----工厂模式

1.什么是工厂模式？

工厂模式，顾名思义，肯定是生产某样东西的，在Java中那肯定是生产对象的啦，在Java中，万物皆对象，传统地我们需要用到对象的时候，通常是new出来，比如我要一个Apple类的实例，就是Apple apple = new Apple();接下来我们就可以使用这个实例，但是这样的话就会造成耦合重的问题，比如现在要更换对象，程序中所有new对象的地方都要修改一遍，这样做就违背了开闭原则；而工厂模式的出现就是为了解决这一问题，我们使用工厂来创建对象，而不是用到的时候new对象，这样我们就可以只跟工厂打交道即可，实现了对象的解耦，如果要更换对象，直接在工厂里面更换就可以了，因此工厂模式最大的特点就是解耦，在Spring中，bean的创建实际上就是工厂模式。

工厂模式的实现可以分为三类：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

2.简单工厂模式

2.1定义

简单工厂模式就是只有一个简单的工厂方法，根据传入的参数，生成对应的产品对象。

2.2简单工厂模式中的各类角色

1. 抽象产品
2. 具体产品
3. 具体工厂
4. 产品使用者

2.3设计详情

先将产品类抽象出来，比如，阿猫和阿狗都属于动物，抽象出来一个动物类Animal，阿猫阿狗就是具体的产品类，然后创建一个动物工厂，分别用来创建阿猫阿狗。

具体代码如下：

动物类

package com.hua.animal;

public interface Animal {
    void whoAmI();//我是谁？
}

阿猫阿狗

package com.hua.animal;

public class Cat implements Animal{
    @Override
    public void whoAmI() {
        System.out.println("I am a cat........");
    }
}

package com.hua.animal;

public class Dog implements Animal{
    @Override
    public void whoAmI() {
        System.out.println("I am a dog.........");
    }
}

 动物工厂

package com.hua.animal;

public class AnimalFactory {
    public Animal creatAnimal(String type){
        if(type.equals("Cat")){//如果传过来的类型是阿猫，那就创建一个阿猫给你
            return new Cat();
        }else if(type.equals("Dog")){//如果传过来的类型是阿狗，那就创建一个阿狗给你
            return new Dog();
        }
        //传的啥啊，我厂里没这玩意儿
        return null;
    }
}

main

package com.hua.animal;

public class AnimalApp {
    public static void main(String[] args) {
        AnimalFactory animalFactory = new AnimalFactory();//获取到工厂实例
        //调用工厂里面的创建方法创建对象
        Cat cat = (Cat) animalFactory.creatAnimal("Cat");
        Dog dog = (Dog) animalFactory.creatAnimal("Dog");
        cat.whoAmI();
        dog.whoAmI();
    }
}

结果 

以上就是简单工厂的简单实现，但是这种工厂模式的缺点很明显，那就是工厂里面我只能创建阿猫阿狗，每当添加一类动物就得修改工厂类，所以这种方式只适合对象比较少而且产品对象固定的情况，对于多变的产品需求来说是不合适的。

3.工厂方法模式

3.1定义

工厂方法模式就是将工厂抽取出来封装成一个接口或者抽象类，具体生产什么产品由继承这个类的子类来决定。

3.2工厂方法模式中的各类角色

1. 抽象产品
2. 具体产品
3. 抽象工厂
4. 具体工厂

3.3设计详情

还是以阿猫阿狗为例。

阿猫阿狗类和Animal接口和上面一样

package com.hua.animal;

public interface Animal {
    void whoAmI();
}

package com.hua.animal;

public class Cat implements Animal{
    @Override
    public void whoAmI() {
        System.out.println("I am a cat........");
    }
}

package com.hua.animal;

public class Dog implements Animal{
    @Override
    public void whoAmI() {
        System.out.println("I am a dog...........");
    }
}

抽象工厂接口

package com.hua.animal;

public interface AnimalFactory {
    Animal createAnimal();//生产动物
}

阿猫工厂实现抽象工厂

package com.hua.animal;

public class CatFactory implements AnimalFactory{
    @Override
    public Cat createAnimal() {
        return new Cat();//生产猫的工厂
    }
}

阿狗工厂实现抽象工厂 

package com.hua.animal;

public class DogFactory implements AnimalFactory{
    @Override
    public Dog createAnimal() {
        return new Dog();//生产狗的工厂
    }
}

使用

package com.hua.animal;

public class AnimalApp {
    public static void main(String[] args) {
        CatFactory catFactory = new CatFactory();//猫工厂实例
        Cat cat = catFactory.createAnimal();//狗工厂实例

        DogFactory dogFactory = new DogFactory();
        Dog dog = dogFactory.createAnimal();

        cat.whoAmI();
        dog.whoAmI();
    }
}

结果 

以上就是工厂方法模式，这种方法实现了解耦，也符合了开闭原则，但是如果需要很多产品的话，就需要创建非常多的工厂，这也是这种方法的缺点。

4.抽象工厂模式

4.1定义

抽象工厂模式支持产品族的创建，就是说如果一个产品的创建需要依赖一些其它对象，比如创建一辆车，车上肯定有许多器件，如空调，轮胎等，这些都是属于它的依赖，创建的时候也要携带上，总不能说使用者要我们工厂创建一辆车，你就给一个空壳子给人家吧。

4.2抽象工厂中的各类角色

1. 抽象产品
2. 具体产品
3. 抽象工厂
4. 具体工厂

4.3设计详情

这里我们还是以阿猫阿狗为例，对于宠物工厂中的配件，狗粮猫粮，这里我们统称为食物food，还有狗绳猫绳，这里统称为绳子rope。也就是说猫的生产需要的配套是猫粮和猫绳，狗的生产需要配套的是狗粮和狗绳。实现如下：

宠物饲料接口以及猫粮狗粮类

package com.hua.animal;

//宠物饲料接口
public interface Food {
    void run();
}


public class CatFood implements Food{
    @Override
    public void run() {
        //猫粮
        System.out.println("cat food........");
    }
}



public class DogFood implements Food{
    @Override
    public void run() {
        //狗粮
        System.out.println("dog food......");
    }
}

宠物绳接口以及猫绳狗绳类

package com.hua.animal;

//宠物绳子接口
public interface Rope {
    void run();
}


public class CatRope implements Rope{
    @Override
    public void run() {
        //猫绳
        System.out.println("cat rope......");
    }
}



public class DogRope implements Rope{
    @Override
    public void run() {
        //狗绳
        System.out.println("dog rope");
    }
}

工厂生产接口

package com.hua.animal;

public interface AnimalFactory {
    //抽象工厂
    Rope configureRope();//配置宠物绳
    Food configureFood();//配置宠物饲料
}

猫工厂类

package com.hua.animal;

//创建阿猫的工厂
public class CatFactory implements AnimalFactory{
    @Override
    public Rope configureRope() {//配个猫绳
        return new CatRope();
    }

    @Override
    public Food configureFood() {//配个猫粮
        return new CatFood();
    }
}

狗工厂类

package com.hua.animal;

//创建狗的工厂
public class DogFactory implements AnimalFactory{
    @Override
    public Rope configureRope() {//配个狗绳
        return new DogRope();
    }

    @Override
    public Food configureFood() {//配个狗粮
        return new DogFood();
    }
}

使用

package com.hua.animal;

public class AnimalApp {
    public static void main(String[] args) {
        CatFactory catFactory = new CatFactory();//猫工厂实例
        Food food = catFactory.configureFood();//猫粮
        Rope rope = catFactory.configureRope();//猫绳
        food.run();
        rope.run();

        System.out.println("====================================");

        DogFactory dogFactory = new DogFactory();//狗工厂实例
        Food food1 = dogFactory.configureFood();//狗粮
        Rope rope1 = dogFactory.configureRope();//狗绳
        food1.run();
        rope1.run();

        //这样，客户端代码就可以通过具体工厂来创建具体产品，而不需要知道具体产品的实现细节。
        // 并且，当需要增加新的产品时，只需增加具体产品类和具体工厂类，而不需要修改已有的代码，符合开闭原则。
    }
}

结果

以上就是抽象工厂的简单实现，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好地管理和扩展。

5.总结

简单工厂模式、工厂方法模式和抽象工厂模式。这些模式都旨在封装对象的创建过程，提供一种灵活的方式来实例化对象。

1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式通过一个工厂类来创建具体产品的实例。客户端只需传递给工厂类一个参数，工厂类根据参数的不同来实例化相应的产品。简单工厂模式适用于创建的产品较少且变化不频繁的情况。但是，它违反了开闭原则，因为每次添加新产品都需要修改工厂类的代码。

2. 工厂方法模式（Factory Method Pattern）：工厂方法模式通过定义一个抽象工厂接口，让具体工厂类来实现这个接口，并负责创建具体产品的实例。每个具体工厂类都对应一个特定的产品，客户端通过调用工厂方法来获取产品。工厂方法模式允许新增产品时无需修改已有代码，符合开闭原则。但是，客户端需要知道具体工厂类的存在，增加了客户端与工厂的耦合。

3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式通过定义一个抽象工厂接口和一组抽象产品接口，每个具体工厂类都负责创建一组产品。客户端只需通过抽象工厂接口来获取产品，无需关心具体工厂或产品的实现细节。抽象工厂模式支持创建一系列相关产品的产品族，并且符合开闭原则。但是，增加新的产品族时需要修改抽象工厂接口和所有具体工厂类的代码，这一点上不符合开闭原则。

三种工厂方式各有优劣，适用于不同的场景。简单工厂模式适用于产品较少且变化不频繁的情况；工厂方法模式适用于需要动态扩展产品种类的场景；抽象工厂模式适用于需要创建一系列相关产品的产品族。选择适合的工厂方式取决于具体的需求和设计目标。