设计模式系统回顾（1） 三个工厂模式（简单，普通，抽象）

其核心目标就是生产对象（需要创建对象时使用）

一 ：简单工厂模式

public interface IProduct {
    void grow();//种植水果
}
public class Apple implements IProduct {
    @Override
    public void grow() {
        System.out.println("种植苹果");
    }
}
public class Orange implements IProduct {
    @Override
    public void grow() {
        System.out.println("种植桔子");
    }
}

// 工厂类
public class SimpleFactory {
    public IProduct createProduct(String productType){
        if("apple".equals(productType)){
            return new Apple();
        }else if("orange".equals(productType)){
            return new Orange();
        }
        return null;
    }

public class TestSimpleFactory {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        IProduct apple = factory.createProduct("apple");
        apple.grow();//输出：种植苹果

        IProduct orange = factory.createProduct("orange");
        orange.grow();//输出：种植桔子
    }
}
}

在上述例子中，每次需要一个对象我就传入参数来获取一个新的对象
应用场景：
创建较少的对象，且工厂不需要太多逻辑的时候
问题：
if分支太多和新增一个商品就要修改工厂类，违背开闭原则，商品多的时候难以维护

二 ：工厂模式

public interface IProduct {
    void grow();
}

public class Apple implements IProduct {
    @Override
    public void grow() {
        System.out.println("种植苹果");
    }
}

public class Orange implements IProduct {
    @Override
    public void grow() {
        System.out.println("种植桔子");
    }
}

public interface IFarmFactory {
    IProduct create();//创建产品
}


public class AppleFactory implements IFarmFactory {
    @Override
    public IProduct create() {
        return new Apple();//苹果工厂生产苹果
    }
}

public class OrangeFactory implements IFarmFactory {
    @Override
    public IProduct create() {
        return new Orange();//桔子工厂生产桔子
    }
}


public class TestFactoryMethod {
    public static void main(String[] args) {
        IFarmFactory appleFactory = new AppleFactory();
        IProduct apple = appleFactory.create();
        apple.grow();//输出：种植苹果

        IFarmFactory orangeFactory = new OrangeFactory();
        IProduct orange = orangeFactory.create();
        orange.grow();//输出：种植桔子
    }
}

在上述例子中，工厂方法也将工厂的职责细化，每种产品都有自己单独的工厂生产线，这也是单一职责的提现
实用场景：
创建对象需要大量重复代码
不关注产品类实例的创建，实现细节
一个类通过子类指定创建对象
缺点：
一个产品需要两个类，产品多了类就多，增加复杂度

二 ：抽象工厂模式

public interface IApple {
    void growApple();//种植苹果
}
public class SouthApple implements IApple {
    @Override
    public void growApple() {
        System.out.println("种植南方苹果");
    }
}
public interface IOrange {
    void growOrange();//种植桔子
}
public class SouthOrange implements IOrange {
    @Override
    public void growOrange() {
        System.out.println("种植南方桔子");
    }
}

public interface IFactory {
    IApple createApple();
    IOrange createOrange();
}

public class SouthFarmFactory implements IFactory {
    @Override
    public IApple createApple() {
        return new SouthApple();//南方农场生产南方苹果
    }

    @Override
    public IOrange createOrange() {
        return new SouthOrange();//南方农场生产南方桔子
    }
}

public class TestAbstractFactory {
    public static void main(String[] args) {
        IFactory southFarmFactory = new SouthFarmFactory();//构建南方农场
        IApple apple = southFarmFactory.createApple();//获得南方苹果
        apple.growApple();//输出：种植南方苹果

        IOrange orange = southFarmFactory.createOrange();//获得南方桔子
        orange.growOrange();//输出：种植南方桔子
    }
}

在上述例子中，南方苹果和其他种类属于苹果，南方橘子则是属于橘子，一系列有共同特点（方法）的产品都可以用某个抽象的类代替（此处为接口）
实用场景：
一系列相似的产品，但是产品实现细节不同的时候，就可以使用抽象工厂将产品抽象化
缺点：
扩展产品相比其他两个要难的多，修改一个东西抽象工厂，具体工厂都需要修改，违背开背原则