设计模式-工厂模式（Factory）

---

一、工厂模式是什么？

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

---

二、工厂模式

案例

1. AnimalFactory（抽象）

// 号称什么宠物都有
public interface AnimalFactory {

    // 可以获取任何的宠物
    Animal createAnimal();
}

2. Animal（抽象）

public abstract class Animal {

    // 所有的动物都会吃东西
    public abstract void eat();
}

3. DogFactory CatFactory（具体）

// 继承着宠物工厂
public class DogFactory implements AnimalFactory {

    // 创建狗
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

// 继承着宠物工厂
public class CatFactory implements AnimalFactory {
    @Override
    // 创建猫
    public Animal createAnimal() {
        return new Cat();
    }
}

4. Dog Cat（具体）

public class Dog extends Animal {

    // 狗喜欢吃肉
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

public class Cat extends Animal {

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

5. test

public class test {
    public static void main(String[] args) {
        // 去找狗工厂拿一只狗过来
        AnimalFactory f = new DogFactory();

        // 店主就拿到了一只狗给Java3y
        Animal a = f.createAnimal();
        a.eat();
        System.out.println("===========");
        // 去找猫工厂拿一只猫过来
        AnimalFactory ff = new CatFactory();

        // 店主就拿到了一只猫给Java3y
        Animal aa = ff.createAnimal();
        aa.eat();
    }
}

6. 结果
   

工厂模式的优缺点

优点

• 客户端不需要在负责对象的创建,明确了各个类的职责
• 如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可
• 不会影响已有的代码,后期维护容易,增强系统的扩展性

缺点

• 需要额外的编写代码,增加了工作量

---

三、简单/静态工厂模式

简单工厂比工厂少一层工厂

案例

1.Factory

public class AnimalFactory {
    public static Dog createDog() {
        return new Dog();
    }

    public static Cat createCat() {
        return new Cat();
    }


    // 外界想要猫要狗，这里创建就好了
    public static Animal createAnimal(String type) {
        switch (type) {
            case "dog":
                return new Dog();
            case "cat":
                return new Cat();
            default:
                return null;
        }
    }
}

2. Animal（抽象）

public abstract class Animal {
    // 所有的动物都会吃东西
    public abstract void eat();
}

3. Cat（实现）

public class Cat extends Animal {

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

}

5. Dog（实现）

public class Dog extends Animal {

    // 狗喜欢吃肉
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

}

6. Test

public class Test {
    public static void main(String[] args) {
        // 拿到狗
        Animal A = AnimalFactory.createAnimal("dog");
        A.eat();
        // 拿到猫
        Animal B = AnimalFactory.createAnimal("cat");
        B.eat();
    }

}

7.结果

简单/静态工厂模式的优缺点

优点

• 具体的工厂来创建对象，代码量少

缺点

• 需求改变了,就要改代码

---

四、抽象工厂模式

抽象工厂比工厂多一层工厂

案例

1. AnimalFactory

public interface AnimalFactory {
    Animal1 createDog();
    Animal1 createCat();
}

2. Animal1

public abstract class Animal1 {

    // 所有的动物都会吃东西
    public abstract void eat();

    // 所有的动物都有性别
    public abstract void gender();
}

3. MaleAnimalFactory FemaleAnimalFactory

public class MaleAnimalFactory implements AnimalFactory {

    // 生产公狗和公猫

    @Override
    public Animal1 createDog() {
        return new MaleDog();
    }

    @Override
    public Animal1 createCat() {
        return new MaleCat();
    }

}

public class FemaleAnimalFactory implements AnimalFactory {

    // 生产母狗和母猫
    @Override
    public Animal1 createDog() {
        return new FemaleDog();
    }

    @Override
    public Animal1 createCat() {
        return new FemaleCat();
    }

}

4. Dog Cat

public abstract class Dog extends Animal1 {

    // 狗喜欢吃肉
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

}

public abstract class Cat extends Animal1 {
    // 猫喜欢吃鱼
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

5. FMaleDog FMaleCat

public class MaleDog extends Dog{

    public void gender() {
        System.out.println(" Male dog");
    }
}

public class MaleCat extends Cat {

    public void gender() {
        System.out.println("MaleCat Cat");
    }

}
public class FemaleDog extends Dog{

    public void gender() {
        System.out.println("female dog");
    }
}
public class FemaleCat extends Cat {

    public void gender() {
        System.out.println("female Cat");
    }

}

6. test

public class test {
    public static void main(String[] args) {
        // 需要性别为母的就去找母工厂
        AnimalFactory af = new FemaleAnimalFactory();

        // 需要一只母猫
        af.createCat().gender();

        // 需要一只母狗
        af.createDog().gender();

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

        // 需要性别为公的就去找公工厂
        AnimalFactory aff = new MaleAnimalFactory();

        // 需要一只公狗
        aff.createDog().gender();

        // 需要一只公猫
        aff.createCat().gender();
    }
}

7. 结果
   

抽象工厂模式的优缺点

优点

• 多了一层抽象，减少了工厂的数量

缺点

• 扩展产品族

---