Java设计模式之工厂模式

前言

工厂模式，顾名思义，即用来实例化一个个对象的模式。把相同类别的对象用工厂模式代替new生成，提高代码质量和系统扩展性。

写法分类

工厂模式的写法通常分为四类，简单工厂、多方法工厂、普通工厂、抽象工厂。
在分别说明他们之前，我们先创建几个对象。
抽象的Animals类，Plants类

public abstract class Animals {  
    //动物的描述  
    public abstract String desc();  
}  

及Animals的三个基本实现，Tiger类、Bird类、Fish类，Plants的实现Tree类。

public class Tiger extends  Animals{  
    @Override  
    public String desc() {  
        System.out.println("这是一只老虎");  
        return "这是一只老虎";  
    }  
}  

public class Bird extends  Animals {  
    @Override  
    public String desc() {  
        System.out.println("这是一只鸟");  
        return "这是一只鸟";  
    }  
}  

public class Fish extends Animals {  
    @Override  
    public String desc() {  
        System.out.println("这是一条鱼");  
        return "这是一条鱼";  
    }  
}  

public abstract class Plants {  
    //植物的描述  
    public abstract String desc();  
}  

public class Tree extends Plants {  
    @Override  
    public String desc() {  
        return "这是一棵树";  
    }  
}  

下面来说说这四种工厂模式。

简单工厂模式

  public class AnimalsFactory {   
    public static final String Tiger="Tiger";  
    public static final String Bird="Bird";  
    public static final String Fish="Fish";  
    public static Animals getAnimal(String name){  
        switch (name){  
            case Tiger:  
                return new Tiger();  
            case Bird:  
                return new Bird();  
            case Fish:  
                return new Fish();  
            default:  
                return null;  
        }  
    }  
} 

调用：

Animals a=AnimalsFactory.getAnimal("Tiger");  
a.desc();  

说明：简单工厂模式易于理解，但扩展性差，如我想在增加一种动物，则还需要修改逻辑内容。而且如果设置额外入参，对参数的管理也较为不便。

多方法工厂模式

public class AnimalsFactory {  
    public static Animals getTiger(){  
        return new Tiger();  
    }  
    public static Animals getBird(){  
        return new Bird();  
    }    
    public static Animals getFish(){  
        return new Fish();  
    }  
}  

调用：

Animals b= AnimalsFactory.getFish();  
b.desc();  

说明：这种模式使用方便，容错率高，且可适应不同需求，如我现在想创建一个羽毛为蓝色的小鸟，明显多方法工厂模式比简单工厂模式实现简单。

普通工厂模式

public abstract class PlantsFactory {  
    public abstract Plants getPlant();  
}  

public class TreeFactory extends PlantsFactory{  
    @Override  
    public Plants getPlant() {  
        return new Tree();  
    }  
}  

调用：

PlantsFactory p=new TreeFactory();  
p.getPlant().desc();

说明：这种工厂模式划分成两层：抽象工厂层+具体的工厂子类层。 当我们不需要Tree，或者需要其他时，都可以新增或删除一个类实现，这种工厂模式看着很简洁明了易于理解。

抽象工厂模式

public  abstract class AbstractFactory<T> {  
    static{  
        // do something  
    }  
    public void doSomeThing(){  
        //do something  
    }  
    private int age;   
    public abstract T getT();  
}  

public class BirdFactory extends AbstractFactory<Animals> {  
    @Override  
    public Animals getT() {  
        return new Bird();  
    }  
}  

public class TreeFactory extends AbstractFactory<Plants> {  
    @Override  
    public Plants getT() {  
        return new Tree();  
    }  
}  

调用：

AbstractFactory factory= new TreeFactory();  
Tree t=(Tree)factory.getT();  
t.desc();  

说明：可以看出，这种方法把工厂本身也抽象了，如果对于两个或多个简单工厂模式，相似点较多，比如PlantsFactory和AnimalsFactory，作为生物，它们也有相似之处，dosomething部分的代码。其实抽象工厂模式跟普通工厂模式的区别就在于把工厂也抽象了一层。

工厂模式实例

1. Spring Bean对象的创建 抽象工厂模式的使用

2. 线程池 Executors 多方法工厂模式的使用

其他：Spring框架中大量使用了工厂模式，单例模式等设计模式，有时间阅读些源代码，对技术能力的提升有很大帮助。

参考资料

1. https://blog.csdn.net/zxt0601/article/details/52798423
2. Spring 4.0 源码
3. JDK8源码

GitHub代码地址

https://github.com/JavaZWT/designPatterns