设计模式 - 工厂模式

工厂模式的三种类型:

1. 简单工厂模式(Simple Factory Parrent)

• 简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类

适用场合: 适用于业务逻辑比较简单的情景(具体原因看下面)

    

具体使用:

    > 第一步: 假设要实现一个描述动物信息功能,我们知道首先要创建一个抽象类 Animal.java,然后想具体描述什么动物,就去继承抽象类,再去添加自己本身独有的属性,

                  我们这里实现一个猫的信息类 Cat.java 和狗的信息类 Dog.java,代码如下:

/**

 * 动物抽象类

 */

public interface IAnimal {

    /**

     * 动物特长

     */

    public String getSpecialty(String specialty);

    /**

     * 动物属性

     */

    public String getInfo();

}

/**

 *  狗的描述信息

 */

public class Dog implements IAnimal{

    /**

     * 狗的特长

     */

    public String getSpecialty(String specialty) {

        return "我会" + specialty;

    }

    public String getInfo() {

        return "我是一条单身狗";

    }

}

/**

 * 猫的描述信息

 */

public class Cat implements IAnimal{

    /**

     * 猫的特长

     */

    public String getSpecialty(String specialty) {

        return "我会" + specialty;

    }

    public String getInfo() {

        return "我是一只可爱的小猫咪";

    }

}

 

    > 第二步 : 当我们想去获得这两个动物的信息和特长的时候,需要分别去 new 这两个对象,比较麻烦,当我们想看哪一个动物的信息的时候,还需要自己去创建对象,我们想的是

               告诉别人我要看哪个动物的信息,他就给我返回这个动物的信息,这里的别人指的就是"工厂",接下来我们来实现这个功能,首先需要一个工厂类(FactoryParrent.java),

               然后我们写一个测试类(TestFactoryParrent.java),我们把具体的获取对象实例的方法交给工厂去做,这样更加符合正常的业务逻辑,但它也有一个问题,比如我们想添

               加一个动物的信息,我们需要创建一个动物的具体实现类,还要去工厂中添加信息,当业务逻辑比较复杂的时候,这种做法会让程序变得很混乱,因为一个项目中可能有几百

               个工厂,当我们要去实现一个新的功能的时候,可能要修改很多类,这不符合设计模式的六大原则中的开闭原则,所以"简单工厂模式"适用于不会再添加新的功能的小项目

               中,这种工厂类也被称为全能类,意思是设计的时候就已经考虑好了所有情况.

/**

 * 工厂类

 */

public class FactoryParrent {

    /**

     * 获取动物信息实例

     * @param animalType 动物类型

     */

    public static IAnimal getInstance(String animalType) throws Exception {

        switch (animalType.toLowerCase()) {

        case "dog":

            return new Dog();

        case "cat":

            return new Cat();

        default:

            throw new Exception("你要查找的动物没有入库");

        }

    }

}       

/**

 * 普通工厂模式测试类

 */

public class TestFactoryParrent {

    public static void main(String[] args) {

        try {

            // 我想知道狗的信息

            IAnimal animal = FactoryParrent.getInstance("dog");

            System.out.println(animal.getInfo());

            // 我想知道猫的信息

            animal = FactoryParrent.getInstance("cat");

            System.out.println(animal.getInfo());

            animal = FactoryParrent.getInstance("pig");

        } catch (Exception e) {

            System.out.println(e.getMessage());

        }

    }

}

# 输出结果:

    我是一条单身狗,我叫 Jerry

    我是一只可爱的小猫咪

    你要查找的动物没有入库

    

2. 工厂方法模式(Factory Method Parrent)

• 工厂方法模式是简单工厂模式的加强版,解决了简单工厂模式的一些缺点,比如"开闭原则",它不需要修改原来的代码,只需要添加新的代码就可以了,它的层次结构更加复杂,

    适用于比较复杂的场景

• 实现原理是对简单工厂模式进行了抽象,抽象类 Factory 将不再负责具体的生产,只是制定一些规则,具体的生产由继承了它的具体工厂类去做,这个时候,其实就是一个具

   体的对象对应一个具体的工厂类,一个抽象类对应一个抽象对象类,添加的代码如下,这样的好处是我们每次增加对象只需要修改对象具体实现类,和具体工厂类这两个类,这样

    有一个缺点就是,逻辑判断放在了客户端,客户端需要修改代码

/**

 * 工厂抽象类

 */

public interface IFactoryParrent {

    public IAnimal getInstance(String animalType) throws Exception;

}

/**

 * 狗的工厂类

 */

public class DogFactoryParrent implements IFactoryParrent {

    /**

     * 获取动物信息实例

     * @param animalType 动物类型

     */

    public IAnimal getInstance(String animalType) throws Exception {

        if(animalType.toLowerCase().equals("dog")) {

            return new Dog();

        }else {

            throw new Exception("你要查找的动物没有入库");

        }

    }

}

/**

 * 猫的工厂类

 */

public class CatFactoryParrent implements IFactoryParrent {

    /**

     * 获取动物信息实例

     * @param animalType 动物类型

     */

    public IAnimal getInstance(String animalType) throws Exception {

        if(animalType.toLowerCase().equals("cat")) {

            return new Cat();

        }else {

            throw new Exception("你要查找的动物没有入库");

        }

    }

}

3. 抽象工厂模式(Abstract Factory Parrent)

• 抽象工厂模式是简单工厂模式的超级加强版，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而

    抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口

    或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

interface IProduct1 { 

    public void show(); 

} 

interface IProduct2 { 

    public void show(); 

} 

class Product1 implements IProduct1 { 

    public void show() { 

        System.out.println("这是1型产品"); 

    } 

} 

class Product2 implements IProduct2 { 

    public void show() { 

        System.out.println("这是2型产品"); 

    } 

} 

// 工厂抽象接口 

interface IFactory { 

    public IProduct1 createProduct1(); 

    public IProduct2 createProduct2(); 

} 

// 工厂实例

class Factory implements IFactory{ 

    public IProduct1 createProduct1() { 

        return new Product1(); 

    } 

    public IProduct2 createProduct2() { 

        return new Product2(); 

    } 

} 

public class Client { 

    public static void main(String[] args){ 

        IFactory factory = new Factory(); 

        factory.createProduct1().show(); 

        factory.createProduct2().show(); 

    } 

} 

  

抽象工厂模式的优点

    抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的

    关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

 

抽象工厂模式的缺点

    产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

 

适用场景

    当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），

    并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品

    进行创建，则更合适一点。