通俗易懂的java设计模式之工厂模式

工厂模式就像一个加工厂一样，假设一个场景，我喜欢吃饺子，那么饺子店就是一个工厂，饺子就是产品的抽象类，猪肉馅饺子，三鲜馅饺子就是具体的产品类。工厂模式主要为创建对象提供了接口，工厂是对象的工厂。工厂模式分为三类。

1.简单工厂模式

工厂类中根据条件决定一个接口由哪个具体产品类来实现。

编写组成：产品抽象类，产品具体类，工厂类

//创建一个饺子的抽象类
public interface JiaoZi{
    //所有的饺子都有自己的描述
    public void desc();
}

//创建一个猪肉饺子作为具体产品类
public class ZhuRouJiaoZi implements JiaoZi {
    public void desc(){
        System.out.println("猪肉饺子")
    }
}

//创建一个三鲜饺子作为具体产品类
public class SanXianJiaoZi implements JiaoZi {
    public void desc(){
        System.out.println("三鲜饺子")
    }
}

//创建一个饺子工厂去根据点餐的不同区生产不同的饺子产品
public class JiaoZiFactory{
    public static final String ZHU_ROU = "猪肉";
    public static final String SAN_XIAN = "三鲜";
    
    //判断点的是什么类型的饺子
    public static JiaoZi createJiaoZi(String type){
        if(ZHU_ROU.equals(type)){
            return new ZhuRouJiaoZi();
        }
        return new SanXianJiaoZi();
    }
}

//工厂类的简单实用测试
public static void main(String[] args){
    JiaoZi jiaozi = JiaoZiFactory.createJiaoZi("三鲜");
    jiaozi.desc();
}

可以看出简单工厂模式工厂类是一个具体的类，有一个创建饺子的静态create方法，在里面利用逻辑去判断生产什么类型的产品，由外部调用静态工厂方法create，来创建产品。缺点很明显，扩展性差，想要添加另一种种类的产品还需要更改工厂类的方法，在不同的产品需要传递不同的参数的时候也无法进行处理。

 

2.工厂方法模式

创建多个工厂类。各个工厂类中，都对应衣蛾获得接口实例的方法，用户决定使用哪个工厂。

编写组成：抽象工厂类，具体工厂类，抽闲产品类，具体产品类

抽象工厂类：工厂模式的核心，是具体工厂必须实现的接口或者继承的父类。用抽象类或者接口实现。

具体工厂类：他含有和业务相关的逻辑代码。来确定创建具体的产品对象。由具体类来实现。

抽象产品类：具体产品需要继承此类。一般由抽象类或者接口实现。

具体产品类：具体工厂创建出来的就是此类的实例。在java中由具体类实现。

//创建一个饺子的抽象类
public interface JiaoZi{
    //所有的饺子都有自己的描述
    public JiaoZi desc();
}

//创建一个猪肉饺子作为具体产品类
public class ZhuRouJiaoZi implements JiaoZi {
    public void desc(){       
        System.out.println("猪肉饺子")
    }
}

//创建一个三鲜饺子作为具体产品类
public class SanXianJiaoZi implements JiaoZi {
    public void desc(){
        System.out.println("三鲜饺子")
    }
}

public interface JiaoZiFactory {
    public JiaoZi createJiaoZi();
}

//创建一个猪肉饺子工厂
public class ZhuRouJiaoZiFactoryImpl implements JiaoZiFactory{
    
    //判断点的是什么类型的饺子
    @Override
    public JiaoZi createJiaoZi(){
   
        return new ZhuRouJiaoZi();
    }
}

//创建一个三鲜饺子工厂
public class SanXianJiaoZiFactoryImpl implements JiaoZiFactory{
    
    //判断点的是什么类型的饺子
    @Override
    public JiaoZi createJiaoZi(){
   
        return new SanXianJiaoZi();
    }
}

//工厂类的简单实用测试
public static void main(String[] args){
    JiaoZiFactory factory = new SanXianJiaoZiFactoryImpl();
    factory.createJiaoZi().desc()
}

工厂方法的模式的优点是当有新的产品产生时完全不需要更改现有的代码。当有新的实例产生时，如添加了一个芹菜的饺子，只需要通过饺子的抽象，和工厂的抽象类共同合成就可以了。符合开闭原则。

3.抽象工厂模式

对工厂方法进行扩展。各个工厂类中，再增加一个获取接口实例的方法。抽象工厂的角色和角色的功能和工厂方法模式如出一辙。

抽象模式适用的场景

饺子馆慢慢做大了，它不仅仅只卖饺子了，现在也想卖包子，这个时候就需要拓展包子的业务，那就需要用到抽象工厂类了。

//创建一个饺子的抽象类
public interface JiaoZi{
    //所有的饺子都有自己的描述
    public void desc();
}

//创建一个猪肉饺子作为具体产品类
public class ZhuRouJiaoZi implements JiaoZi {
    public void desc(){       
        System.out.println("猪肉饺子")
    }
}

//创建一个三鲜饺子作为具体产品类
public class SanXianJiaoZi implements JiaoZi {
    public void desc(){
        System.out.println("三鲜饺子")
    }
}

//创建一个包子的抽象类
public interface BaoZi{
    //所有的饺子都有自己的描述
    public void bdesc();
}

//创建一个猪肉包子作为具体产品类
public class ZhuRouBaoZi implements BaoZi {
    public void bdesc(){       
        System.out.println("猪肉饺子")
    }
}

//创建一个三鲜包子作为具体产品类
public class SanXianBaoZi implements BaoZi {
    public void bdesc(){
        System.out.println("三鲜饺子")
    }
}

//创建一个工厂的工厂
public interface AbstractFactory {

    public JiaoZi createJiaoZi();

    public BaoZi createBaoZi();

}

//创建一个三鲜工厂
public class SanXianFactory implements AbstractFactory {
    
    //重写抽象工厂方法
    @Override
    public JiaoZi createJiaoZi(){
   
        return new SanXianJiaoZi();
    }

    @Override
    public BaoZi createBaoZi(){
   
        return new SanXianBaoZi();
    }
}

//创建一个猪肉工厂
public class ZhuRouFactory implements AbstractFactory {
    
    //重写抽象工厂方法
    @Override
    public JiaoZi createJiaoZi(){
   
        return new ZhuRouJiaoZi();
    }

    @Override
    public BaoZi createBaoZi(){
   
        return new ZhuRouBaoZi();
    }
}

//工厂类的简单实用测试
public static void main(String[] args){
    AbstractFactory factory = new SanXianFactory();
    factory.createJiaoZi().desc()
}

抽象工厂模式要满足两个条件，一个是系统中需要有多个产品族，系统一次只可能消费其中一组产品。其次，同属于一个产品族的产品一起使用。在本例中产品族就是猪肉，和三鲜。

 

总结

无论是简单工厂还是其他的工厂，最终目的都是为了解耦 ，只要能达到这个目的就行了，不要太在意使用的哪种工厂模式。