设计模式之工厂模式

1、基本介绍：
工厂模式是一种创建型模式，将实例化对象的代码提取出来，封装到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展性和维护性。工厂模式可分为简单工厂模式、工厂方法模式、抽象工厂模式三种，下面依次介绍（以生产手机为例）。

2、简单工厂模式
2.1、基本介绍：
简单工厂模式定义了一个创建对象的类，这个类封装了实例化对象的行为（代码），由一个工厂对象决定创建出哪一种产品类的实例。
2.2、UML类图：

2.3、代码演示：

1. 定义手机标准规范类（AbstractProduct）

public interface Phone {
    void create();
}

2. 小米手机（Product1）

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

3. 苹果手机（Product2）

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

4. 手机工厂（Factory）

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

5. 使用简单工厂

public class Main {
    public static void main(String[] args) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.createPhone("MiPhone");            // create xiaomi phone!
        IPhone iPhone = (IPhone)factory.createPhone("iPhone");    // create iphone!
    }
}

3、工厂方法模式
3.1、基本介绍：
工厂方法模式定义了一个创建对象的抽象方法，由子类决定要实例化的类，将对象的实例化推迟到子类。
3.2、UML类图：

3.3、代码演示：

1. 生产不同产品的工厂的抽象类

public interface AbstractFactory {
    Phone createPhone();
}

2. 生产小米手机的工厂（ConcreteFactory1）

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

3. 生产苹果手机的工厂（ConcreteFactory2）

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

4. 使用工厂方法

public class Main{
    public static void main(String[] args) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.createPhone();  // create xiaomi phone!
        appleFactory.createPhone(); // create iphone!
    }
}

4、抽象工厂模式
4.1、基本介绍：
抽象工厂定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类，可以将简单工厂模式和工厂方法模式进行整合，对简单工厂模式的改进（或称为进一步的抽象）。将工厂抽象成两层，抽象工厂和具体实现的工厂子类，根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
4.2、UML类图：

4.3、代码演示：

1. 定义PC产品的接口（AbstractPC）

public interface PC {
    void create();
}

2. 定义小米电脑产品（MIPC）

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

3. 定义苹果电脑产品（MAC）

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

4. 增加PC产品制造接口

public interface AbstractFactory {
    Phone createPhone();
    PC createPC();
}

5. 增加小米PC的制造（ConcreteFactory1）

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

6. 增加苹果PC的制造（ConcreteFactory2）

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

7. 使用抽象工厂

public class Main {
    public static void main(String[] args) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.createPhone();       // create xiaomi phone!
        miFactory.createPC();          // create xiaomi PC!
        appleFactory.createPhone();    // create iphone!
        appleFactory.createPC();       // create MAC!
    }
}

至此，三种工厂模式介绍完毕。