简单工厂&工厂方法&抽象工厂

一、简单工厂（Simple factory）
集中管理对象的产生，业务代码只需要调用相应的方法，
传入不同的参数区分对象，就能得到想要的对象了
把业务代码和对应的对象解耦

创建一个抽象类
public abstract class CellPhone {
    protected String name;

    public CellPhone(String name){
        this.name = name;
    }

    public abstract void show();
}

创建实现抽象类的实体类
第一个实体类：
public class HuaweiPhone extends CellPhone {

    public HuaweiPhone(String name) {
        super(name);
    }
    @Override
    public void show() {
        System.out.println("华为生产的:" + name);
    }
}

第二个实体类：
public class XiaomiPohone extends CellPhone {

    public XiaomiPohone(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("小米生产的:" + name);
    }
}

enum PhoneType{
    XIAOMI_PHONE,
    HUAWEI_PHONE
}

创建一个简单工厂类
class Factory{
    public static CellPhone getPhone(PhoneType pt){
        switch(pt){
            case XIAOMI_PHONE:
                return new XiaomiPohone("小米6x");
            case HUAWEI_PHONE:
                return new HuaweiPhone("荣耀6x");
            default:
                System.out.println("无效的手机类型");
        }
        return null;
    }
}

使用该工厂，通过传递类型信息来获取实体类的对象：
public class FactoryTest {
    public static void main(String[] args) {
        CellPhone cp = Factory.getPhone(PhoneType.HUAWEI_PHONE);
        cp.show();

        cp = Factory.getPhone(PhoneType.XIAOMI_PHONE);
        cp.show();
        }
 }

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。不符合软件设计的开-闭原则 ，对工厂的代码修改无法关闭。

二、工厂方法（Factory Method ）
解决了简单工厂存在的缺点
优点：把工厂代码对修改关闭了，添加新的产品，创建新的工厂模式就可以继承Factory就可以了。
缺点：不能良好地解决有依赖关系的一组对象的创建， 短时间内造成大量工厂产生。

创建一个抽象类
public abstract class CellPhone {
    protected String name;

    public CellPhone(String name){
        this.name = name;
    }

    public abstract void show();
}

抽象类的实现类
第一个实现类
public class HuaweiPhone extends CellPhone {

    public HuaweiPhone(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("华为生产的:" + name);
    }
}
第二个实现类
public class XiaomiPohone extends CellPhone {

    public XiaomiPohone(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("小米生产的:" + name);
    }
}

创建一个工厂类
abstract class Factory{
    public abstract CellPhone createPhone(String name);
}

class XiaomiFactory extends Factory{

    @Override
    public CellPhone createPhone(String name) {
        return new XiaomiPohone(name);
    }
}

class HuaweiFactory extends Factory{

    @Override
    public CellPhone createPhone(String name) {
        return new HuaweiPhone(name);
    }
}

使用该工厂
public class FactoryTest {

    public static void main(String[] args) {

        Factory f1 = new XiaomiFactory();
        Factory f2 = new HuaweiFactory();

        CellPhone p1 = null;

        p1 = f1.createPhone("小米6x");
        p1.show();

        p1 = f2.createPhone("荣耀6x");
        p1.show();
    }
}

工厂方法：
好处：把工厂代码对修改关闭了，添加新的产品，创建新的工厂继承Factory就行了
不好：不能良好的解决，有依赖关系的一组对象的创建
三、抽象工厂（Abstract Factory ）
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
介绍
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决：解决了一类没在一个继承关系上，但是产品之间有依赖关系的一组对象的创建
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。
实现：
在之前的工厂方法上，新增加一个类，相当于给工厂类增加一种产品
之前的生产手机代码不变，现在要让工厂再生产运动手环

运动手环抽象类
abstract class SportCircle{
    protected String name;

    public SportCircle(String name) {
        this.name = name;
    }

    public abstract void show();
}

class MiSportCircle extends SportCircle{

    public MiSportCircle(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("小米生产的:" + name);
    }
}

class HuaweiSportCircle extends SportCircle{

    public HuaweiSportCircle(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("华为生产的:" + name);
    }
}

抽象工厂
abstract class AbstractFactory{
    public abstract CellPhone createPhone(String name);
    public abstract SportCircle createCircle(String name);
}

class XiaoMiFactory extends AbstractFactory{

    @Override
    public CellPhone createPhone(String name) {
        return new XiaomiPohone(name);
    }

    @Override
    public SportCircle createCircle(String name) {
        return new MiSportCircle(name);
    }
}

class HuaweiFactory extends AbstractFactory{

    @Override
    public CellPhone createPhone(String name) {
        return new HuaweiPhone(name);
    }

    @Override
    public SportCircle createCircle(String name) {
        return new HuaweiSportCircle(name);
    }
}

使用该工厂
public class FactoryTest {

    public static void main(String[] args) {

        AbstractFactory f1 = new XiaoMiFactory();
        AbstractFactory f2 = new HuaweiFactory();

        CellPhone cp = null;
        cp = f2.createPhone("荣耀手机");
        cp.show();
        cp = f1.createPhone("小米手机");
        cp.show();

        SportCircle sc = null;
        sc = f2.createCircle("华为运动手环");
        sc.show();
        sc = f1.createCircle("小米运动手环");
        sc.show();
    }
}