设计模式---工厂模式

简单工厂模式

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产 品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式；

简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)，在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

 以手机为例简单演示简单工厂模式

标准规划类

/**
 * @author Siwang Xu
 * @create 2021/10/7-14:48
 * Phone类：手机标准规范类(AbstractProduct)
 */
public interface Phone {
    void make();
}

实体手机1

/**
 * @author Siwang Xu
 * @create 2021/10/7-14:52
 */
public class Miphone implements Phone {
    public Miphone(){
        this.make();
    }

    @Override
    public void make() {
        System.out.println("造出小米手机");
    }
}

手机2

/**
 * @author Siwang Xu
 * @create 2021/10/7-14:52
 */
public class Iphone implements Phone {
    public Iphone(){
        this.make();
    }

    @Override
    public void make() {
        System.out.println("造出苹果手机");
    }
}

代工厂

/**
 * @author Siwang Xu
 * @create 2021/10/7-14:55
 * 代工厂
 */
public class PhoneFactory {
    public Phone makePhone(String order){
        if(order.equals("Miphone")){
            return new Miphone();
        }else if(order.equals("Iphone")){
            return new Iphone();
        }
        return null;
    }
}

测试类

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:00
 */
public class Client {
    public static void main(String[] args) {
        PhoneFactory phoneFactory=new PhoneFactory();
        System.out.println(phoneFactory.makePhone("Iphone"));
        System.out.println(phoneFactory.makePhone("Miphone"));
    }
}

 工厂方法模式

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。

继续使用生产手机的例子来讲解该模式。其中和产品相关的Phone类、MiPhone类和IPhone类的定义不变。

新增抽象工厂

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:23
 */
public interface AbstrcatFactory {
    Phone makePhone();
}

新增具体工厂1

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:24
 */
public class MiFactory implements AbstrcatFactory {
    @Override
    public Phone makePhone() {
        return new Miphone();
    }
}

新增具体工厂2

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:25
 */
public class IFactory implements AbstrcatFactory {
    @Override
    public Phone makePhone() {
        return new Iphone();
    }
}

 测试

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:28
 */
public class Client {
    public static void main(String[] args) {
        AbstrcatFactory miFactory=new MiFactory();
        AbstrcatFactory iFactory=new IFactory();
        miFactory.makePhone();
        iFactory.makePhone();
    }
}

 简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。而后者则增加了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则。

抽象工厂模式 

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品Phone（AbstractProduct），如果要生成另一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式完全复制一份，不过这次生产的是PC。但同时也就意味着我们要完全复制和修改Phone生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护。

抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步 的抽象)。
将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。.

 抽象工厂

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:59
 */
public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

实例工厂1

/**
 * @author Siwang Xu
 * @create 2021/10/7-16:03
 */
public class IpFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new Iphone();

    }

    @Override
    public PC makePC() {
        return new MAC();
    }
}

实例工厂2

/**
 * @author Siwang Xu
 * @create 2021/10/7-16:01
 */
public class XiMiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new Miphone();
    }

    @Override
    public PC makePC() {
        return new MiPc();
    }
}

PC接口

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:55
 */
public interface PC {
    void make();
}

PC实例

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:56
 */
public class MiPc implements PC {
    public MiPc(){
        this.make();
    }
    @Override
    public void make() {
        System.out.println("生产小米电脑");
    }
}

/**
 * @author Siwang Xu
 * @create 2021/10/7-15:58
 */
public class MAC implements PC {
    public MAC(){
        this.make();
    }
    @Override
    public void make() {
        System.out.println("生产苹果电脑");
    }
}

测试

/**
 * @author Siwang Xu
 * @create 2021/10/7-16:06
 */
public class Client {
    public static void main(String[] args) {
        AbstractFactory miFactory=new XiMiFactory();
        AbstractFactory ipFactory=new IpFactory();
        miFactory.makePC();
        miFactory.makePhone();
        ipFactory.makePhone();
        ipFactory.makePC();
    }
}

 JDK中的Calendar类即为简单工厂模式

工厂模式小结
1) 工厂模式的意义
将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2)三种工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)
3)设计模式的依赖抽象原则
➢创建对象实例时，不要直接new类,而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
➢不要让类继承具体类， 而是继承抽象类或者是实现interface(接口)
➢不要覆盖基类中已经实现的方法。