设计模式——工厂方法模式、抽象工厂模式

模式引入：

工厂：任何可以产生对象的方法或者类。

简单工厂

注：这不属于23中设计模式之一

场景引入

首先，我们想象这样一个场景：创业初期，一个人开了一个工厂生产手机和智能手表。（现实生活中，当然是先生产一个，但是为了好写一些，就假装有两种产品，其实一种产品的也算）

代码实现

device interface

/*
接口,用来说明设备的生产过程
*/

public interface device {
    void process();
}

phone.class

// 手机类，用来说明手机是怎么生产的
public class phone implements device{
    public void process() {
        System.out.println("手机的生产过程就是先这样这样，再那样那样，就生产出来了");
    }
}

Watch.class

// 智能手环，用来说明智能手环是怎么生产的
public class Watch implements device {
    public void process() {
        System.out.println("智能手环的生产方式就是先那样那样，再这样这样，就生产出来了");
    }
}

SimpleFactory.class

//这就是开的那个工厂，可以生产手机和智能手环
public class SimpleFactory {
    public device create(String s){
        if(s.equals("phone")){
            return new phone();
        }else if(s.equals("watch")){
            return new Watch();
        } else { **//注意这里**
            throw new RuntimeException("你说的产品我们还没有，如果你们需要，我们今后会生产的");
        }
    }
}

test.class

public class Test {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        device phone = factory.create("phone");
        phone.process();
        device watch = factory.create("watch");
        watch.process();
        /*
        **注意这里**
        device ipad = factory.create("ipad");
        ipad.process();
         */

    }
}

代码简要说明

在简单工厂中，我们只需要说明，我们需要的是什么，工厂就能调用相应的方法给我们生产出我们需要的设备。

拓展

注意在SimpleFactory类中的最后一个else语句，以及test类中最后一个注释掉的语句。如下：
SimpleFactory:

Test:
想象一个具体的情况：创业者觉得自己现在生产的东西不够多，想要更多的产品。（当然，一般情况下是：人们觉得这个工厂生产的东西好，想要看看这个工产是都生产其他产品。比如这里代码中的ipad）。这种情况下，我们就需要在原来的代码中增加一个Ipad类：

public class Ipad implements device{
    public void process() {
        System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了");
    }
}

然后为了这个工产能够生产Ipad，SimpleFactory类就需要改成下面这样：

public class SimpleFactory {
    public device create(String s){
        if(s.equals("phone")){
            return new phone();
        }else if(s.equals("watch")){
            return new Watch();
        }else if(s.equals("ipad")){
            return new Ipad();
        } else {
            throw new RuntimeException("你说的产品我们还没有，如果你们需要，我们今后会生产的");
        }
    }
}

增加一个ipad类其实并不影响，主要问题出现在修改了SimpleFactory类中的代码。这就好比为了生产新的产品Ipad，发现原来的场地不够用，就把原来的工产拆了，然后建了一个更大的工厂（有钱任性，我们管不了，但是至少正常人不会这么干）。这样就显示出了简单工场模式的缺点：扩展性差。就是说不能生产新的产品。

工厂方法模式

场景引入

但是，如果创业者想要把企业做大，他肯定会在工厂中生产新产品。（有钱人总想变得更有钱，只有我被贫穷蒙蔽的双眼）。那么如果我们要生产新的产品，上面说的简单共产模式就不管用了，就引入了我们的工厂方法模式。这就好像是：为每一个设备创建一个工厂

代码实现

device interface

/*
接口,用来说明设备的生产过程
*/

public interface device {
    void process();
}

phone.class

// 手机类，用来说明手机是怎么生产的
public class phone implements device{
    public void process() {
        System.out.println("手机的生产过程就是先这样这样，再那样那样，就生产出来了");
    }
}

Watch.class

// 智能手环，用来说明智能手环是怎么生产的
public class Watch implements device {
    public void process() {
        System.out.println("智能手环的生产方式就是先那样那样，再这样这样，就生产出来了");
    }
}

Ipad.class

// Ipad，用来说明Ipad是怎么生产的
public class Ipad implements device{

    public void process() {
        System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了");
    }
}

Factory.class

//把厂抽象出来，自己不做具体的生产实现
public  abstract class Factory {
     abstract device create();
}

phoneFactory.class

//生产手机的工厂，具体实现生产手机
public class phoneFactory extends Factory {

    device create() {
        return new phone();
    }
}

WatchFactory.class

//生产智能手表的工厂，具体实现生产智能手表
public class WatchFactory extends Factory{
    device create() {
        return new Watch();
    }
}

IpadFactory.class

//生产Ipad的工厂，具体实现生产Ipad
public class IpadFactory extends Factory{

    device create() {
        return new Ipad();
    }
}

Test.class

public class Test {
    public static void main(String[] args) {
        Factory factory = new WatchFactory();
        device watch = factory.create();
        watch.process();
        factory = new IpadFactory();
        device ipad = factory.create();
        ipad.process();
        factory = new phoneFactory();
        device phone = factory.create();
        phone.process();

    }
}

代码简要说明

在共产方法模式下，工厂不在做具体的生产实现，而是交给各个具体的分工厂去实现。但是，这种情况下，这时候，你要的产品就通过产品的具体类名体现出来：

这时候，当增加新的产品时，我们就不需要再改变工厂类了。比如，我们要增加一个新的产品：电脑。只需要增加新的类和具体的工厂。如下：
Computer：

public class Computer implements device{
    public void process() {
        System.out.println("电脑就是瞎捯饬捯饬就生产出来了");
    }
}

ComputerFactory

public class ComputerFactory extends Factory{
    device create() {
        return new Computer();
    }
}

然后我们再测试类中就可以直接使用了：
Test：

public class Test {
    public static void main(String[] args) {
        Factory factory = new WatchFactory();
        device watch = factory.create();
        watch.process();
        factory = new IpadFactory();
        device ipad = factory.create();
        ipad.process();
        factory = new phoneFactory();
        device phone = factory.create();
        phone.process();
        
        factory = new ComputerFactory();
        device computer = factory.create();
        computer.process();

    }
}

这就好像是开分工厂一样，这样就不需要将原来的工厂拆除，再建新的工厂。

抽象工厂模式

情景引入

刚刚那个创业者成功了，这时候就开始有人眼红了。于是，也想开始和他一样，做同样的工厂。因为有了前人的经验，新来的创业者发现这个工厂生产的东西已经固定下来了，而且用多个分厂，用显得非常的麻烦。于是，新来的创业者开的厂就把这些整合起来，用一个厂进行生产。抽象工厂模式的概念就是：一个抽象类中包含多个抽象产品类

代码实现

device interface

/*
接口,用来说明设备的生产过程
*/

public interface device {
    void process();
}

phone.class

// 手机类，用来说明手机是怎么生产的
public class phone implements device{
    public void process() {
        System.out.println("手机的生产过程就是先这样这样，再那样那样，就生产出来了");
    }
}

Watch.class

// 智能手环，用来说明智能手环是怎么生产的
public class Watch implements device {
    public void process() {
        System.out.println("智能手环的生产方式就是先那样那样，再这样这样，就生产出来了");
    }
}

Ipad.class

// Ipad，用来说明Ipad是怎么生产的
public class Ipad implements device{

    public void process() {
        System.out.println("Ipad就是这样弄一下，那样弄一下，就生产出来了");
    }
}

Computer.class

public class Computer implements device{
    public void process() {
        System.out.println("电脑就是瞎捯饬捯饬就生产出来了");
    }
}

Factory.class

public  abstract class Factory {
     abstract device phoneCreate();
     abstract device ipadCreate();
     abstract device watchCreate();
     abstract device computerCreate();
}

NewFactory.class

public class NewFactory extends Factory {
    device phoneCreate() {
        System.out.println("我是新创业者");
        return new phone();
    }

    device ipadCreate() {
        System.out.println("我是新创业者");
        return new Ipad();
    }

    device watchCreate() {
        System.out.println("我是新创业者");
        return new Watch();
    }

    device computerCreate() {
        System.out.println("我是新创业者");
        return new Computer();
    }
}

OldFactory.class

public class OldFactory extends Factory{
    device phoneCreate() {
        System.out.println("我是老创业者");
        return new phone();
    }

    device ipadCreate() {
        System.out.println("我是老创业者");
        return new Ipad();
    }

    device watchCreate() {
        System.out.println("我是老创业者");
        return new Watch();
    }

    device computerCreate() {
        System.out.println("我是老创业者");
        return new Computer();
    }
}

Test.class

public class Test {
    public static void main(String[] args) {
        Factory factory = new NewFactory();
        device Newfactory = factory.computerCreate();
        Newfactory.process();
        Newfactory = factory.ipadCreate();
        Newfactory.process();
        Newfactory = factory.phoneCreate();
        Newfactory.process();
        Newfactory = factory.watchCreate();
        Newfactory.process();
        System.out.println("==============");
        factory = new OldFactory();
        device old = factory.computerCreate();
        old.process();
        old = factory.ipadCreate();
        old.process();
        old = factory.phoneCreate();
        old.process();
        old = factory.watchCreate();
        old.process();
    }
}

代码解读

抽象工厂模式就像是工厂方法模式的整合，因为那里面的具体工厂太多了，就显得很复杂，将一些产品放在一起进行抽象工厂，就会减少其复杂性。

写在最后

故事完整串联简单工厂模式，工厂方法模式、抽象工厂模式：简单工厂模式就像是早期的工厂，当要增加生产新的产品。因为地方不够，就用分工厂来进行解决，其实这里我们把简单共产模式想成早期的生产一样产品的更好理解。然后当新工厂不断增加时，工厂太多就不好进行管理，然后将一些工厂进行整合，形成抽象工厂模式。这就好像时现实生活中的工厂有很多的生产线，每条工厂线生产不同的产品。生活中就是将每个共产的量缩小，使得每个工厂都能生产公司的所有产品。或者是一个人用别人已有的模式来进行生产。具体的情况有很多很多。说多了，更容易让人不好理解，我就不多说啦。QAQ，该睡觉了，不然要猝死了。不懂的可以留言~~~~~