Java设计模式之 工厂模式解析

工厂模式一般用于当我们创建复杂对象时，通过简单的new来创建会比较麻烦，这时候我们就可以使用工厂模式来创建一个工厂类，我们只需向工厂类中传入需要创建的类的有关信息即可，工厂类中实现了创建对象的复杂细节。

比如我们创建一个制造汽车的工厂类，我们传入不同的车型号，制造出不同的车。

 

简单工厂模式：

创建一个工厂类，在类中通过传入的参数不同创建不同的实体类。有新需求时需要更改工厂类中的代码，违背了开闭原则。

interface Car{
    public void factory();
}
class BMW implements Car{
    public void factory() {
        System.out.println("生产宝马！");
    }
}
class Benz implements Car{
    public void factory() {
        System.out.println("生产奔驰！");
    }
}
class Audi implements Car{
    public void factory() {
        System.out.println("生产奥迪！");
    }
}

class CarFactory{
    public static Car carFactory(Class class1){
        if (class1.getName().equals(BMW.class.getName())){
            return new BMW();
        }
        if (class1.getName().equals(Benz.class.getName())){
            return new Benz();
        }
        if (class1.getName().equals(Audi.class.getName())){
            return new Audi();
        }
        return null;
    }
}

public class FactoryTest1 {
    public static void main(String[] args) {
        Car car = CarFactory.carFactory(BMW.class);
        car.factory();
    }
}Class class1){
        if (class1.getName().equals(BMW.class.getName())){
            return new BMW();
        }
        if (class1.getName().equals(Benz.class.getName())){
            return new Benz();
        }
        if (class1.getName().equals(Audi.class.getName())){
            return new Audi();
        }
        return null;
    }
}

public class FactoryTest1 {
    public static void main(String[] args) {
        Car car = CarFactory.carFactory(BMW.class);
        car.factory();
    }
}

执行结果：

 

多方法静态工厂模式：

创建一个工厂类，在工厂类中写多个静态方法来创建对应的类。当有新的需求时，只需要增删工厂类中的静态方法就行了。

interface Car{
    public void factory();
}
class BMW implements Car{
    public void factory() {
        System.out.println("生产宝马！");
    }
}
class Benz implements Car{
    public void factory() {
        System.out.println("生产奔驰！");
    }
}
class Audi implements Car{
    public void factory() {
        System.out.println("生产奥迪！");
    }
}

class CarFactory{
    public static Car BMWfactory(){
        return new BMW();
    }
    public static Car Benzfactory(){
        return new Benz();
    }
    public static Car Audifactory(){
        return new Audi();
    }

}

public class FactoryTest1 {
    public static void main(String[] args) {
        Car car = CarFactory.Benzfactory();
        car.factory();
    }
}

 

工厂方法模式：

设置一个工厂接口，通过其他的类实现这个接口来创建实例。不仅实体要抽象，工厂也要抽象，由具体的工厂类来创建对象。当有新的需求时，只需要添加或者删除具体工厂类就行了，不需要修改已有的已有类中的代码。

interface Car2{
    public void factory();
}
class BMW2 implements Car2{
    public void factory() {
        System.out.println("生产宝马！");
    }
}
class Benz2 implements Car2{
    public void factory() {
        System.out.println("生产奔驰！");
    }
}
class Audi2 implements Car2{
    public void factory() {
        System.out.println("生产奥迪！");
    }
}
//抽象工厂
interface CarFactory2{
    public Car2 carfactory();
}
//具体工厂类
class BMWfactory2 implements CarFactory2{

    @Override
    public Car2 carfactory() {
        return new BMW2();
    }
}
class Benzfactory2 implements CarFactory2{

    @Override
    public Car2 carfactory() {
        return new Benz2();
    }
}
class Audifactory2 implements CarFactory2{

    @Override
    public Car2 carfactory() {
        return new Audi2();
    }
}
public class FactoryTest2 {
    public static void main(String[] args) {
        Car2 BMW = new BMWfactory2().carfactory();
        BMW.factory();
    }
}

 

抽象工厂模式：

抽象工厂就是一个工厂不单生产一个种类的产品，而是生产多个种类的产品，也就是生产相关产品的产品家族。

比如现在工厂不仅生产汽车，还生产飞机。

interface Car2{
    public void factory();
}
class BMW2 implements Car2{
    public void factory() {
        System.out.println("生产宝马！");
    }
}
class Benz2 implements Car2{
    public void factory() {
        System.out.println("生产奔驰！");
    }
}
class Audi2 implements Car2{
    public void factory() {
        System.out.println("生产奥迪！");
    }
}
interface Plane{
    void planeFactory();
}
class BattlePlane implements Plane{
    public void planeFactory() {
        System.out.println("生产战斗机！");
    }
}
class Airplane implements Plane{
    public void planeFactory() {
        System.out.println("生产客机！");
    }
}
class Spacecraft implements Plane{
    public void planeFactory() {
        System.out.println("生产宇宙飞船！");
    }
}

//抽象工厂
interface Factory2{
    public Car2 carfactory();
    public Plane planefactory();
}
//具体工厂类
class FFfactory1 implements Factory2{

    @Override
    public Car2 carfactory() {
        return new BMW2();
    }

    @Override
    public Plane planefactory() {
        return new BattlePlane();
    }
}
class FFfactory2 implements Factory2{

    @Override
    public Car2 carfactory() {
        return new Benz2();
    }

    @Override
    public Plane planefactory() {
        return new Airplane();
    }
}
class FFfactory3 implements Factory2{

    @Override
    public Car2 carfactory() {
        return new Audi2();
    }

    @Override
    public Plane planefactory() {
        return new Spacecraft();
    }
}
public class FactoryTest2 {
    public static void main(String[] args) {
        Car2 Benz = new FFfactory2().carfactory();
        Benz.factory();
        Plane battleplane = new FFfactory1().planefactory();
        battleplane.planeFactory();
    }
}

 

工厂模式使用场景：

当我们直接new一个对象比较麻烦时，比如构造方法传参数量太多，例如ThreadPoolExecutor类构造方法有5个参数，其中三个参数写法固定，前两个参数可配置，如下。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

再比如创建一个类A要先创建类B，这种使用new比较麻烦时就可以交给工厂去做，还减少了代码的重复。