这篇文章主要为学习笔记。

什么时候使用工厂设计模式呢？

如果是一般来说，我们需要制作一杯可乐。那就创建一个可乐对象。那么如果产生了一个判断，例如：夏天生产可乐，冬天生产咖啡。已经不是直接创建对象了，而是一个过程。

简单工厂模式。

情景：咖啡，可乐。那么我们需要一个生产商，来生产咖啡或者是可乐

class Drink{
    public Drink(){}
}

class Cola extends Drink{
    public Cola(){
        System.out.println("cola");
    }
}

class Coffee extends Drink{
    public Coffee(){
        System.out.println("Coffee");
    }
}

class Producer{
    public static Drink getDrink(String season){
        if(season.equalsIgnoreCase("Summer")){
            return new Cola();    
        }else if(season.equalsIgnoreCase("Winter")){
            return new Coffee();
        }
    }    
}

class Demo{
    public static void main(String[] args){
        Drink cola=Producer.getDrink("summer");
        Drink coffee=Producer.getDrink("winter");
    }    
}

工厂方法模式

不是直接对可乐进行操作了，而是对可乐的生产商进行操作。我想要可乐，那么就去制作可乐的生厂商。

class Drink{
    public Drink(){}    
}

class Cola extends Drink{
    public Cola(){
        System.out.println("cola");
    }
}

class Coffee extends Drink{
    public Coffee(){
        System.out.println("coffee");
    }    
}

abstract class Producer{
    public abstract Drink getDrink();
}

class ColaProducer extends Producer{
    @override
    public Cola getDrink(){
        return new Cola();
    }
}

class CoffeeProducer extends Producer{
    @override
    public Coffee getDrink(){
        return new Coffee();
    }    
}

class Demo{
    public static void main(String[] args){
        CoffeeProducer coffeeProducer=new CoffeeProducer();
        Coffee coffee=coffeeProducer.getDrink();
    
        ColaProducer colaProducer=new ColaProducer();
        Cola cola=colaProducer.getDrink();
    }    
}

抽象工厂模式:

饮料和添加物。

饮料：可乐，咖啡。添加物：冰块和牛奶。

生产商为饮料生产商和添加物生产商。如果是夏天，那么饮料生产商生产可乐 ，添加物生产商生产冰块。

class Drink{
    public Drink(){}    
}

class Cola extends Drink{
    public Cola(){
        System.out.println("cola");
    }
}

class Coffee extends Drink{
    public Coffee(){
        System.out.println("coffee");
    }
}

abstract class Additive{
    public abstract void add();
}

class Ice extends Additive{
    @override
    public void add(){
        System.out.println("ice cake");
    }
}

class Milk extends Additive{
    @override
    public void add(){
        System.out.println("milk");
    }    
}

abstract class AbstractProducer{
    public abstract Drink getDrink(String season);
    public abstract Additive getAdditive(String additive);
}

class DrinkProducer extends AbstractProducer{
    @override 
    public Drink getDrink(String season){
        if(season.equalsIgnoreCase("Summer")){
            return new Cola();    
        }else if(season.equalsIgnoreCase("Winter")){
            return new Coffee();
        }
        return null;
    }

    @override
    public Additive getAdditive(String additive){
        return null;
    }
}

class AdditiveProducer extends AbstractProducer{
    @override
    public Drink getDrink(String season){
        return null;
    }   

    @override
    public Additive getAdditive(String additive){
        if(additive.equalsIgnore("ice")){
            return new Ice();
        }else if(additive.equalsIgnore("milk")){
            return new Milk();
        }
        return null;
    } 
}

class Demo{
    public static void main(String[] args){
        DrinkProducer drinkProducer=new DrinkProducer();
        Cola cola=drinkProducer.getDrink("summer");

        AddtiveProducer additiveProducer=new AdditiveProducer();
        Ice ice=additiveProducer.getAdditive("ice");
        ice.add();
    }
}

总结：

简单工厂模式:接口/父类 子类实现 工厂类

工厂方法模式:接口/父类 子类实现 工厂父类 工厂子类实现

抽象工厂模式:接口/父类 子类实现 接口/父类 子类实现 工厂父类 工厂子类实现