简单工厂模式

定义：专门定义一个类用来创建其他类的实例，被创建的实例通常都具有共同的父类。

例如有客户要选择两个品牌的手机，小米和华为，这时候客户只需要把选择type交给Factory，Factory根据type来创建各品牌手机的实例。
简单工厂java代码实现如下

interface Phone{
    public void printPhone();
}


public class XiaoMiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a XiaoMi Phone");
    }
}

public class HuaWeiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a HuaWei Phone");
    }
}

public class PhoneFactory {
    public Phone createPhone(String type) {
        Phone p = null;
        if(type.equals("xiaomi")) {
            p = new XiaoMiPhone ();
        }else if(type.equals("huawei")) {
            p = new HuaWeiPhone ();
        }
        return p;
    }
}

public class Client {
    public void buy(Phone p){
        System.out.println("I buy a phone");
        p.printComputer();
    }
    public static void main(String[] args) {

        Client c = new Client();
        PhoneFactory pf = new PhoneFactory ();

        Phone p= pf .createPhone("xiaomi");
        c.buy(p);
    }
}

但是问题来了如果，如果客户来选择其他手机品牌MeiZu，就需要修改工厂类PhoneFactory r 代码，添加type为meizu的品牌。违反了对扩展开放，对修改关闭的原则，即“开闭原则”

开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭

所以简单工厂模式的优缺点：
优点：工厂Factory负责产生具体的实例对象，实现具体的逻辑，通过客户的输入就可以得到具体的实例，客户不需要知道各类型实例的具体实现，交给工厂即可。
缺点：违反了“开闭原则”。

针对简单工厂模式的缺点，我们需要改良工厂模式，这就出现了工厂方法模式。

工厂方法模式

定义：定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类。

实现方式与简单工厂模式的区别是，把之前的PhoneFactory抽象成一个接口，每一个手机品牌都有一个对应的PhoneFactory的实现类。

interface Phone{
    public void printPhone();
}


public class XiaoMiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a XiaoMi Phone");
    }
}

public class HuaWeiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a HuaWei Phone");
    }
}

public interface PhoneFactory {
    public Phone createPhone();
}

public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }
}

public class HuaWeiFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new HuaWeiPhone();
    }
}

public class Client {
    public void buy(Phone p){
        System.out.println("I buy a phone");
        p.printPhone();
    }
    public static void main(String[] args) {

        Client c = new Client();
        PhoneFactory pf = new XiaoMiFactory();

        Phone p = pf.createPhone();
        c.buy(p);
    }
}

优点：工厂方法模式下，如果要新增手机品牌，会新添加对应的产品类和工厂类去实现接口，不需要修改原来存在的代码，符合“开闭原则”。
缺点：客户性必须要感应具体的工厂类，也就是判断逻辑移到了客户端。

抽象工厂模式

定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。
例如在生产手机的时候也创建操作系统。
java代码如下

interface Phone{
    public void printPhone();
}


public class XiaoMiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a XiaoMi Phone");
    }
}

public class HuaWeiPhone implements Phone {
    @Override
    public void printPhone() {
        System.out.println("This is a HuaWei Phone");
    }
}

public interface OperatingSystem {
    public void printSystem();
}

public class XiaoMiSystem implements OperatingSystem{
    @Override
    public void printSystem() {
        System.out.println("This is a MIUI");
    }
}

public class HuaWeiSystem implements OperatingSystem {
    @Override
    public void printSystem() {
        System.out.println("This is an EMUI");
    }
}

public interface PhoneFactory {
    public Phone createPhone();
    public OperatingSystem createSystem();
}

public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public OperatingSystem createSystem() {
        return new XiaoMiSystem();
    }
}

public class HuaWeiFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public OperatingSystem createSystem() {
        return new HuaWeiSystem();
    }
}

public class Client {
    public void buy(Phone p){
        System.out.println("I buy a phone");
        p.printPhone();
    }
    public void use(OperatingSystem s) {
        System.out.println("Operating System");
        s.printSystem();
    }
    public static void main(String[] args) {

        Client c = new Client();
        PhoneFactory pf = new XiaoMiFactory();

        Phone p = pf.createPhone();
        OperatingSystem os=pf.createSystem();
        c.buy(p);
        c.use(os);
    }
}

与工厂方法模式相比，工厂类多加了一个方法。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。