工厂方法模式

• 定义
• 适用场景
• 代码示例(Java)
  • 先有一个产品
  • 再有个抽象工厂类
  • 然后实现抽象工厂类
  • 最后测试

定义

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而不需要指定具体的类。工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

适用场景

1. 当一个类不知道它所必须创建的对象的类的时候。
2. 当一个类希望由它的子类来指定它所创建的对象的时候。
3. 当一个类将创建对象的职责委托给多个帮助类中的某一个，并且你希望将哪一个帮助类是代理者这一信息局部化的时候。
4. 当一个类中的构造函数参数很多，且这些参数会随着业务场景的变化而变化时，可以使用工厂方法模式来简化对象的创建过程。
5. 当需要创建的对象有复杂的创建逻辑时，可以使用工厂方法模式将复杂的创建逻辑封装在工厂类中，使代码更加清晰和易于维护。
6. 当需要创建的对象有多个子类，并且每个子类都需要单独创建时，可以使用工厂方法模式来避免代码重复。
7. 当需要创建的对象需要根据不同的条件进行不同的创建时，可以使用工厂方法模式来将创建逻辑封装在工厂类中，使代码更加灵活和可扩展。

代码示例(Java)

先有一个产品

现有一个动物接口，定义了动物的通用行为

package com.design.mode.factory.method.one;

public interface Animal {

    /**
     * 叫
     */
    void call();
    /**
     * 吃
     */
    void eat();

    /**
     * 睡觉
     */
    void sleep();

    /**
     * getName
     * @return 名字
     */
    String name();

    /**
     * 跑
     */
    void run();

    /**
     * 飞
     */
    void fly();

    /**
     *
     */
    void swim();
}

再声明一些动物，比如狗、猫、鸟、鱼

package com.design.mode.factory.method.one.entity;

import com.design.mode.factory.method.one.Animal;

public class Cat implements Animal {
    private final String name;

    public Cat() {
        this.name = "普通猫";
    }

    public Cat(String name) {
        this.name = name;
    }

    @Override
    public void call() {
        System.out.println("喵喵喵");
    }

    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("睡觉");
    }

    @Override
    public String name() {
        return this.name;
    }

    @Override
    public void run() {
        System.out.println("跑");
    }

    @Override
    public void fly() {
        System.out.println("猫不会飞");
    }

    @Override
    public void swim() {
        System.out.println("猫不会游泳");
    }
}

package com.design.mode.factory.method.one.entity;

import com.design.mode.factory.method.one.Animal;

public class Dog implements Animal {
    @Override
    public void call() {
        System.out.println("汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println("吃狗骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗睡觉");
    }

    @Override
    public String name() {
        return "狗子";
    }

    @Override
    public void run() {
        System.out.println("狗跑");
    }

    @Override
    public void fly() {
        System.out.println("狗不会飞");
    }

    @Override
    public void swim() {
        System.out.println("狗刨式");
    }
}

package com.design.mode.factory.method.one.entity;

import com.design.mode.factory.method.one.Animal;

public class Duck implements Animal {
    @Override
    public void call() {
        System.out.println("嘎嘎嘎");
    }

    @Override
    public void eat() {
        System.out.println("吃蚯蚓");
    }

    @Override
    public void sleep() {
        System.out.println("睡觉");
    }

    @Override
    public String name() {
        return "鸭子";
    }

    @Override
    public void run() {
        System.out.println("鸭子跑");
    }

    @Override
    public void fly() {
        System.out.println("鸭子飞不高");
    }

    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }
}

package com.design.mode.factory.method.one.entity;

import com.design.mode.factory.method.one.Animal;

public class Fish implements Animal {
    @Override
    public void call() {
        System.out.println("鱼不会叫");
    }

    @Override
    public void eat() {
        System.out.println("鱼吃浮游生物");
    }

    @Override
    public void sleep() {
        System.out.println("鱼会睡觉");
    }

    @Override
    public String name() {
        return "鱼";
    }

    @Override
    public void run() {
        System.out.println("鱼不会跑");
    }

    @Override
    public void fly() {
        System.out.println("鱼不会飞");
    }

    @Override
    public void swim() {
        System.out.println("鱼会游泳");
    }
}

再有个抽象工厂类

package com.design.mode.factory.method.one;

public abstract class AnimalFactory {
    public abstract Animal createAnimal();
}

然后实现抽象工厂类

package com.design.mode.factory.method.one.factory;

import com.design.mode.factory.method.one.Animal;
import com.design.mode.factory.method.one.AnimalFactory;
import com.design.mode.factory.method.one.entity.Cat;

import java.util.Random;

public class CatFactory extends AnimalFactory {
    Random random = new Random();
    @Override
    public Animal createAnimal() {
        if(random.nextDouble() > 0.5) {
            return new Cat("波斯猫");
        }
        return new Cat();
    }
}

package com.design.mode.factory.method.one.factory;

import com.design.mode.factory.method.one.Animal;
import com.design.mode.factory.method.one.AnimalFactory;
import com.design.mode.factory.method.one.entity.Dog;

public class DogFactory extends AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

package com.design.mode.factory.method.one.factory;

import com.design.mode.factory.method.one.Animal;
import com.design.mode.factory.method.one.AnimalFactory;
import com.design.mode.factory.method.one.entity.Dog;

public class DuckFactory extends AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

package com.design.mode.factory.method.one.factory;

import com.design.mode.factory.method.one.Animal;
import com.design.mode.factory.method.one.AnimalFactory;
import com.design.mode.factory.method.one.entity.Fish;

public class FishFactory extends AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Fish();
    }
}

最后测试

package com.design.mode.factory.method.one;

import com.design.mode.factory.method.one.factory.CatFactory;

public class OneMain {
    public static void main(String[] args) {
        AnimalFactory factory = new CatFactory();
        Animal animal = factory.createAnimal();
        System.out.println(animal.name());
        animal.call();
        animal.eat();
        animal.fly();
        animal.run();
        animal.sleep();
        animal.swim();
    }
}