设计模式-工厂模式总结

工厂模式

工厂顾名思义就是创建产品，主要作用是解耦。
根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，
根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。

1. 简单工厂模式

• 创建产品接口
• 创建具体工厂类
• 创建工厂，根据类型生产不同的产品

Phone类：手机标准规范类(AbstractProduct)

public interface Phone {
    void make();
}

MiPhone类：制造小米手机（Product1）

public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}

IPhone类：制造苹果手机（Product2）

public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}

PhoneFactory类：手机代工厂（Factory）

public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}

使用

public class Demo {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
    }
}

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

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂。

• 创建工厂接口，指明生产产品
• 创建具体产品类实现工厂接口，重写生产产品方法
• 使用时创建具体产品类

AbstractFactory类：生产不同产品的工厂的抽象类

public interface AbstractFactory {
    Phone makePhone();
}

XiaoMiFactory类：生产小米手机的工厂（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

AppleFactory类：生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();       
        appleFactory.makePhone();    
    }
}

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

抽象工厂模式可以看成是简单工厂和工厂方法的结合。

• 先创建简单工厂中的产品接口
• 创建具体的产品实现简单工厂中的产品接口
• 创建工厂方法的工厂接口
• 创建具体的工厂实现工厂方法
• 使用：new 具体的工厂，调用工厂的生产方法即可

创建产品接口

PC类：定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

创建具体产品实现产品接口

MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

MAC类：定义苹果电脑产品(MAC)

public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

创建工厂接口

AbstractFactory类：增加PC产品制造接口

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

创建具体工厂实现工厂接口

XiaoMiFactory类：增加小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

AppleFactory类：增加苹果PC的制造（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

总结

工厂模式，根据生活中可知，工厂可以生产一件或者多见产品（接口或者抽象类实现），
而怎么生产产品由具体的类实现，而产品有哪些行为，可以通过接口定义

简单工厂：（单个对象：手机）
1. 创建产品接口，定义相关方法
2. 创建产品实现类，并实现 1 中的接口
3. 创建工厂，根据不同的类型 type 去生产 2 中的对象
4. 通过对象去调用 2 中的相关方法

工厂方法：（单个对象：手机）
1. 创建工厂接口，定义创建具体类的方法
2. 创建具体工厂，实现 1 中的接口，并创建具体类
3. 使用时直接创建具体工厂

抽象工厂：（多个对象：手机、电脑）
1. 创建产品接口，定义相关方法
2. 创建产品具体实现类，实现 1 中的接口
3. 创建工厂抽象接口，并创建具体类
4. 创建具体的工厂，实现 3 中的接口，并创建具体类
5. 使用时直接创建具体工厂

参考

• 菜鸟教程-工厂模式