设计模式之工厂模式

一、什么是工厂模式

        工厂模式属于创建型模式，提供了一种创建对象的方式。

        对于创建对象，最简单的创建对象方式莫过于直接new一个对象，对于简单对象，这确实是一个简单快速的方式，但是对于一个复杂对象的创建而言，就不是那么适合了。因为使用者需要对这个对象非常了解，才能创建出符合要求的对象。实际上，工厂模式把对象的创建和对象的使用隔离开了。举个例子：线程池Executors.newFixedThreadPool(int nThreads) 方法返回了一个ThreadPoolExecutor，ThreadPoolExecutor的构造方法参数有6个，但是调用Executors.newFixedThreadPool(int nThreads)方法，我们只传递了1个参数，工厂模式把对象的创建向使用者隐藏起来了。

        另外一种使用工厂模式的场景在于，向使用者隐藏类的真实类型。在面向接口编程的场景下，假如我们使用的类（FooImpl1, FooImpl2）都继承了某个抽象类Foo，使用者需要实例化某个类，那么使用者就必须清楚某个具体类，这就打破了面向接口编程，变成了面向实现编程，所以我们这个时候需要一个工厂类，工厂类的方法返回抽象类Foo，而不是具体的某个实现。

        总而言之，工厂的目的在于创建，为什么需要工厂创建而不是我们自己动手创建？要么就是这个产品（对象）的创建工作很复杂，交给专业人士（工厂）；要么是我们根本不知道怎么创建，只能交给工厂（面向接口编程情况下，我们不知道实现类，所以无法创建）。

二、简单工厂模式

         简单工厂模式，实现起来也很简单。

         假设我们有一个产品Phone，实现类有IPhone，AndroidPhone，有一个生产Phone的工厂PhoneFactory。PhoneFactory提供一个方法，能够根据Phone的名称生产Phone。

        Phone：

public interface Phone {

    void call();

}

        IPhone：

public class IPhone implements Phone {
    @Override
    public void call() {
        System.out.println("IPhone calling...");
    }
}

        AndroidPhone:

public class AndroidPhone implements Phone {
    @Override
    public void call() {
        System.out.println("Android phone calling...");
    }
}

        PhoneFactory:

public class PhoneFactory {

    public static Phone createPhone(String phoneName) {
        Phone phone = null;
        switch (phoneName) {
            case "IPhone":
                phone = new IPhone();
                break;
            case "AndroidPhone":
                phone = new AndroidPhone();
                break;
            default:
                phone = null;
                break;
        }
        return phone;
    }

}

        Main:

public class Main {

    public static void main(String[] args){
        Phone phone = PhoneFactory.createPhone("AndroidPhone");
        phone.call();
    }

}

        使用字符串指定需要生产的Phone类型似乎不够优雅，因为字符串容易拼错，所以我们可以指定类名来决定生产哪种类型的Phone，所以修改代码如下：

        PhoneFactory：

public class PhoneFactory {

    public static Phone createPhone(Class<? extends Phone> phone) {
        if (null != phone) {
            try {
                return phone.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

}

        Main:

public class Main {

    public static void main(String[] args){
        Phone phone = PhoneFactory.createPhone(AndroidPhone.class);
        phone.call();
    }

}

三、工厂方法模式

        不知道大家注意到没有，简单工厂模式并不够“面向接口编程”，因为当我们使用Phone工厂类来生产Phone，需要指定具体的Phone子类，所以我们需要另外一种方式，不需要指定具体子类就可以生产Phone。

        Phone接口、IPhone类和AndroidPhone类保留，现在添加一个工厂方法模式的工厂类PhoneFactory。

        PhoneFactory：

public class PhoneFactory {

    public static Phone createIPhone() {
        return new IPhone();
    }
    
    public static Phone createAndroidPhone() {
        return new AndroidPhone();
    }

}

        Main：

public class Main {

    public static void main(String[] args){
        Phone androidPhone = PhoneFactory.createAndroidPhone();
        androidPhone.call();
    }

}

        现在调用者不需要知道具体的Phone类型就可以使用工厂生产出具体的Phone了。

四、抽象工厂模式

        简单工厂模式和工厂方法模式都只能生产一个种类的产品，假如我们需要生产多个种类的产品，比如我们还需要生产另外一个品种：watch。添加接口Watch，以及两个实现类AppleWatch、AndroidWatch。

        Watch：

public interface Watch {
    
    void getTime();
    
}

        AppleWatch：

public class AppleWatch implements Watch {
    @Override
    public void getTime() {
        System.out.println("Get time from Apple Watch...");
    }
}

        AndroidWatch：

public class AndroidWatch implements Watch {
    @Override
    public void getTime() {
        System.out.println("Get time from Android watch...");
    }
}

        现在开始使用工厂类生产watch了，等等。。。我们现在只有PhoneFactory，难道我们使用PhoneFactory来生产watch？这是肯定不行的，至少这样违反了单一职责原则。之前我们把产品抽象了，现在，我们需要把工厂也进行抽象。

        定义一个抽象工厂AbstractFactory，这个抽象工厂具有两个方法，分别是生产手机的createPhone()，和生产手表的createWatch()。

        AbstractFactory：

public interface AbstractFactory {
    
    Phone createPhone();
    
    Watch createWatch();
    
}

        接下来定义两个具体的实现类来实现抽象工厂。

        AppleProductFactory：

public class AppleProductFactory implements AbstractFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }

    @Override
    public Watch createWatch() {
        return new AppleWatch();
    }
}

        AndroidProductFactory:

public class AndroidProductFactory implements AbstractFactory {
    @Override
    public Phone createPhone() {
        return new AndroidPhone();
    }

    @Override
    public Watch createWatch() {
        return new AndroidWatch();
    }
}

        Main：

public class Main {

    public static void main(String[] args){
        AbstractFactory androidProductFactory = new AndroidProductFactory();
        Phone androidPhone = androidProductFactory.createPhone();
        Watch androidWatch = androidProductFactory.createWatch();
        androidPhone.call();
        androidWatch.getTime();
    }

}