工厂模式

工厂模式的意义：让对象的创建变得简单，用户只需要把需求给到工厂，工厂就能创建一个对象。简化对象的创建过程。

                             修改对象很方便，只要修改工厂中的创建方式即可，而调用者完全不用修改。

工厂demo

package factoryPattern;

public interface Milk {
    /**
     * 获取一个标准产品
     * */
     String getName();

}

package factoryPattern;

public class Sanlu implements Milk {
    @Override
    public String getName() {
        return "三鹿";
    }
}

package factoryPattern;


public class Telunsu implements Milk {
    @Override
    public String getName() {
        return "Telunsu";
    }
}

package factoryPattern;


public class Yili implements Milk {
    @Override
    public String getName() {
        return "伊利";
    }
}

package factoryPattern;


public class MengNiu implements Milk {
    @Override
    public String getName() {
        return "蒙牛";
    }
}

简单工厂模式

package factoryPattern.simple;

import factoryPattern.MengNiu;
import factoryPattern.Milk;
import factoryPattern.Telunsu;
import factoryPattern.Yili;

public class SimpleFactory {
    public Milk getMilk(String name){
        if("特仑苏".equals(name)){
            return  new Telunsu();
        }if("伊利".equals(name)){
            return  new Yili();
        }if("蒙牛".equals(name)){
            return new MengNiu();
        }else{
                return null;
        }

    }
}

package factoryPattern.simple;


public class SimpleTest {
    public static void main(String[] args) {
        //用户不用关心生产过程，只关心结果
        //加入：生成的对象的属性都是不同的
        SimpleFactory factory = new SimpleFactory();
        //把用户的需求告诉工厂，工厂就给你一个具体的产品
        //创建产品的过程隐藏了，对于用户而言完全不清楚怎么产生的  
        //缺点： 用户可能传一个工厂无法接收的参数
        System.out.println(factory.getMilk("蒙牛"));
    }

}

工厂方法模式

package factoryPattern.func;

import factoryPattern.Milk;

/**
 * 工厂方法模型
 * */
public interface Factory {

    //工厂必然具有生产产品的技能，统一的产品出口
    Milk getMilk();
}

package factoryPattern.func;

import factoryPattern.MengNiu;
import factoryPattern.Milk;


public class MengniuFactory implements Factory {
    @Override
    public Milk getMilk() {
        return new MengNiu();
    }
}

package factoryPattern.func;

import factoryPattern.Milk;
import factoryPattern.Sanlu;


public class SanLuFactory implements Factory {
    @Override
    public Milk getMilk() {
        return new Sanlu();
    }
}

package factoryPattern.func;

import factoryPattern.Milk;
import factoryPattern.Telunsu;


public class TlelunsuFactory implements  Factory {
    @Override
    public Milk getMilk() {
        return new Telunsu();
    }
}

package factoryPattern.func;

import factoryPattern.Milk;
import factoryPattern.Yili;


public class YiliFactory implements Factory {
    @Override
    public Milk getMilk() {
        return new Yili();
    }
}

package factoryPattern.func;


public class FactoryTest {
    public static void main(String[] args) {
       // System.out.println(new Factory().getMilk());
        //增加了用户的复杂度， 需要一个配置。其实用户不关心他是哪个工厂，也不清楚有没有这个工厂类
        //缺点：用户可能会配置错
        Factory factory = new SanLuFactory();
        System.out.println(factory.getMilk());
    }
}

抽象工厂模式

package factoryPattern.abstr;

import factoryPattern.Milk;

/**
 * @description: 抽象工厂是用户的主入口,
 * 在Spring中应用的最为广泛的设计模式
 * 易于扩展,如果有改动只需要升级一下API就行了
 **/
public abstract  class AbstractFactory {

    //公共的逻辑、方便与统一管理
    //接口不能存储逻辑，抽象类可以存储逻辑

    //差异化的定制可以写在不同的方法中去
    /**
     * 获得一个蒙牛品牌的牛奶
     * @return
     */
    public abstract Milk getMengniu();

    /**
     * 获取YiLi品牌的牛奶
     * @return
     */
    public abstract Milk getYili();

    /**
     * 获取telunsu品牌的牛奶
     * @return
     */
    public abstract  Milk getTlunsu();

    /**
     *
     * @return
     */
    public abstract Milk getSanlu();
}

package factoryPattern.abstr;

import factoryPattern.MengNiu;
import factoryPattern.Milk;
import factoryPattern.Sanlu;
import factoryPattern.Telunsu;
import factoryPattern.Yili;


public class MilkFactory extends AbstractFactory {
    @Override
    public Milk getMengniu() {
        return new MengNiu();
    }

    @Override
    public Milk getYili() {
        return new Yili();
    }

    @Override
    public Milk getTlunsu() {
        return new Telunsu();
    }

    @Override
    public Milk getSanlu() {
        return new Sanlu();
    }
}

/**
 * @description:
 * AbstractFactoryTest就像用户自己，而AbstractFactory与MilkFactory就像Spring的工厂，Spring只会把abstract接口暴露给我们
 * 当发生改变时我们只需要去更新AbstractFactoryApi即可，不会关心其他中的实现，当有新的功能发布，
 * 在使用的时候只要get就好了
 **/
public class AbstractFactoryTest {
    public static void main(String[] args) {
        MilkFactory factory = new MilkFactory();
        //milkFactory.getXXX() 用户只有选择的权利，保证了程序的健壮性
        System.out.println(factory.getSanlu());

    }
}