java23种设计模式—工厂模式

设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

工厂模式简而言之就是用来创建对象的，属于创建型设计模式。此类模式还包括单例模式、建造者模式、原型模式。工厂模式主要有工厂方法模式和抽象工厂模式。

静态工厂模式

静态工厂模式的实现很简单，简单到有的设计模式书籍都不它当做一种设计模式，而仅仅作为一种普通的代码组织方式。我们以汽车工厂为例展开。 首先创建一个Car接口：

public interface Car {

    public void desc();

}

 

接着创建两个汽车类，奔驰和法拉利，当然也可以创建更多。

 

public class Benz implements Car {
    @Override
    public void desc() {
        System.out.println("I am Benz.");
    }
}

public class Ferrari implements Car{
    @Override
    public void desc() {
        System.out.println("I am Ferrari.");
    }
}

 

我们需要一个汽车工厂用来根据用户需要生产各种各样的汽车。

 

public class CarFactory {
    
    Car car = null;
    
    public Car creatCat(String type) {
        if (type.equals("Benz")) {
            car = new Benz();
        } 
        if (type.equals("Ferrari")) {
            car = new Ferrari();
        }
        return car;
    }
    
}

 

然后创建一个Client类模拟客户端创建汽车。

 

public class Client {
    
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.creatCat("Benz").desc();
        carFactory.creatCat("Ferrari").desc();
    }
}

 

运行后输出如下：

 

I am Benz.
I am Ferrari.

静态工厂解耦了用户和具体对象创建的耦合程度，客户无需知道对象是如何创建的，仅需要告诉工厂我需要什么样的车即可。

工厂方法模式

静态工厂的缺陷也很明显，当我们有新的汽车类型产生的时候，就必须更改CarFactory类，添加一个汽车类型，不符合开闭原则。工厂方法模式正好可以避免这种缺陷。

先创建一个汽车工厂接口ICarFactory。各类汽车的工厂都实现该接口。

public interface ICarFactory {
    
    Car creatCar();
}

/**
 * Benz汽车工厂
 */
public class BenzFactory implements ICarFactory{
    
    @Override
    public Car creatCar() {
        return new Benz();
    }
}

/**
 * Ferrari汽车工厂
 */
public class FerrariFactory implements ICarFactory {
    
    @Override
    public Car creatCar() {
        return new Ferrari();
    }
}

/**
 * 客户端
 */
public class Client {
    
    public static void main(String[] args) {
        ICarFactory benzFactory = new BenzFactory();
        Car benz = benzFactory.creatCar();
        benz.desc();
        
        ICarFactory ferrariFactory = new FerrariFactory();
        Car ferrari = ferrariFactory.creatCar();
        ferrari.desc();
    }
}

 

客户端更具自己的需求选择不同的汽车工厂生产汽车。当新增了汽车类型时，再创建一个工厂即可。抽象工厂模式假设汽车工厂可以生产不同档次的汽车，比如说普通的和高档的。我们可以这样定义一个抽象汽车工厂接口。

 

/**
 * 普通汽车
 */
public class OrdinaryCar implements Car{
    @Override
    public void desc() {
        System.out.println("我是普通汽车。");
    }
}

/**
 * 豪华汽车
 */
public class LuxuriousCar implements Car {
    @Override
    public void desc() {
        System.out.println("我是豪华汽车。");
    }
}
/**
 * 抽象工厂接口
 */
public interface AbatractCarFactory {
    
    Car creatOrdinaryCar();
    
    Car creatLuxuriousCar();
}

/**
 * 具体汽车工厂
 */
public class CarFactory implements AbatractCarFactory{
    
    @Override
    public Car creatOrdinaryCar() {
        return new OrdinaryCar();
    }

    @Override
    public Car creatLuxuriousCar() {
        return new LuxuriousCar();
    }
}
/**
 * 客户端
 */
public class Client {
    
    public static void main(String[] args) {
        AbatractCarFactory carFactory = new CarFactory();
        Car ordinaryCar = carFactory.creatOrdinaryCar();
        ordinaryCar.desc();
        
        Car luxuriousCar = carFactory.creatLuxuriousCar();
        luxuriousCar.desc();
    }
}
输出：
我是普通汽车。
我是豪华汽车。

抽象工厂模式适合具体产品种类稳定的场合。如果汽车档次增加的话，就不得不更改AbatractCarFactory以适应变化。

 

更多设计模式原创文章：

原型模式

单例模式

建造者模式

工厂模式

策略模式