Java设计模式：工厂模式

目录

1、简单工厂模式

2、工厂方法模式

3、抽象工厂模式

4、总结

---

核心本质:
        实例化对象不使用new，用工厂方法代替。将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 

1、简单工厂模式

        简单工厂模式：用来生产同一等级结构中的任意产品(对于增加新的产品，需要球盖已有代码）

实现

1.创建一个接口

public interface Animals {
    void name();
}

2.创建实现接口的实体类

public class Cat implements Animals {
    @Override
    public void name() {
        System.out.println("猫");
    }
}

public class Dog implements Animals{
    @Override
    public void name() {
        System.out.println("狗");
    }
}

3.创建一个工厂，生成基于给定信息的实体类的对象

public class AnimalsFactory {
    public static Animals getAnimals(String name){
        if(name.equals("猫")){
            return new Cat();
        }else if(name.equals("狗")){
            return new Dog();
        }else {
            return null;
        }
    }
}

4.使用该工厂，通过传递类型信息来获取实体类的对象。

public class Test {
    public static void main(String[] args) {
        Animals animals1 = AnimalsFactory.getAnimals("猫");
        Animals animals2 = AnimalsFactory.getAnimals("狗");
        animals1.name();
        animals2.name();
    }
}

5.执行程序，输出结果

优点：工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

缺点：由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连；而且由于简单工厂模式的产品室基于一个共同的抽象类或者接口，这样一来，但产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种种类的产品，这就和创建何种种类产品的产品相互混淆在了一起，违背了单一职责，导致系统丧失灵活性和可维护性。而且更重要的是，简单工厂模式违背了“开放封闭原则”，就是违背了“系统对扩展开放，对修改关闭”的原则，因为当我新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。

2、工厂方法模式

        工厂方法模式：用来生产同一等级结构中的固定产品(支持增加任意产品)

实现

1.创建两个接口

public interface Animals {
    void name();
}

创建一个工厂接口，提供一个方法 

public interface AnimalsFactory {
    Animals getAnimals();
}

2.创建实现接口的实体类

public class Cat implements Animals{
    @Override
    public void name() {
        System.out.println("猫");
    }
}

public class Dog implements Animals {
    @Override
    public void name() {
        System.out.println("狗");
    }
}

3.每个实体类继承工厂接口创建一个工厂

public class CatFactory implements AnimalsFactory{
    @Override
    public Animals getAnimals() {
        return new Cat();
    }
}

public class DogFactory implements AnimalsFactory{
    @Override
    public Animals getAnimals() {
        return new Dog();
    }
}

4.使用工厂，直接得到动物

public class Test {
    public static void main(String[] args) {
        Animals animals1 = new CatFactory().getAnimals();
        Animals animals2 = new DogFactory().getAnimals();
        animals1.name();
        animals2.name();
    }
}

5.执行程序，输出结果

优点：
        1、一个调用者想创建一个对象，只要知道其名称就可以了。
        2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
        3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

3、抽象工厂模式

抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

定义︰抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类
适用场景:
        客户端（应用层)不依赖于产品类实例如何被创建、实现等细节
        强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
        提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

实现

public class Test {
    public static void main(String[] args) {
        System.out.println("===华为系列产品===");
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        IphoneProduct iphoneProduct1 = huaweiFactory.iphoneProduct();
        iphoneProduct1.callup();
        iphoneProduct1.sendSMS();
        ComputerProduct computerProduct1 = huaweiFactory.computerProduct();
        computerProduct1.seemovie();
        computerProduct1.playgame();

        System.out.println("===小米系列产品===");
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        IphoneProduct iphoneProduct2 = xiaomiFactory.iphoneProduct();
        iphoneProduct2.callup();
        iphoneProduct2.sendSMS();
        ComputerProduct computerProduct2 = xiaomiFactory.computerProduct();
        computerProduct2.seemovie();
        computerProduct2.playgame();
    }
}

运行结果：

优点:
        具体产品在应用层的代码隔离，无需关心创建的细节
        将一个系列的产品统一到一起创建
缺点：
        规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难
        增加了系统的抽象性和理解难度

4、总结

        简单工厂模式（静态工厂模式)
                虽然某种程度上不符合设计原则，但实际使用最多!

        工厂方法模式
                不修改已有类的前提下，通过增加新的工厂类实现扩展。

        抽象工厂模式
                不可以增加产品，可以增加产品族!