工厂设计模式

工厂：故名思议，就是用来制造各种产品的，在程序中主要是用来创建对象。

• 首先介绍下简单工厂（也称静态工厂）

class Car{
    
    public void run(){
        System.out.println("小车正在跑。。");
    }
}

public class SampleFactoryTest {

    public static void main(String[] args) {
        //调用者创建一个Car
        Car car = new Car();
        //调用者调用run方法
        car.run();
    }
}

通过以上代码，你有没有发现一个问题。就是调用者（main方法）在调用小车的run()之前还需要创建一个Car对象，就好比你想要开车，你会不会自己先做一辆车然后再去开？我想你不会的。所以为了让调用者和创建者分离，工厂设计模式应允而生。

class Car{
    
    public void run(){
        System.out.println("小车正在跑。。");
    }
}
/**
 * 汽车工厂
 *
 */
class CarFactory{
    //加上static方便调用，也称静态工厂
    public static Car createCar(){
        return new Car();
    }
    
}

public class SampleFactoryTest {

    public static void main(String[] args) {
        //通过工厂创建一个Car
        Car car = CarFactory.createCar();
        //调用者调用run方法
        car.run();
    }
}

实际应用当然不止才一个类型的车，下面是一个详细的例子：

interface Car{
    
    public void run();
}

class Benz implements Car{

    @Override
    public void run() {
        System.out.println("奔驰在跑...");
    }
    
}

class Bmw implements Car{

    @Override
    public void run() {
        System.out.println("宝马在跑...");
    }
    
}
/**
 * 汽车工厂
 *
 */
class CarFactory{
    /**
     * 简单工厂一般加上static方便访问
     * 通过不同类型获得不同的车
     * @param type 类型
     * @return 车
     */
    public static Car createCar(String type){
        Car car = null;
        if(type.equals("benz")){
            car = new Benz();
        } else if(type.equals("bmw")){
            car = new Bmw();
        }
        return car;
    }
    
}
/**
 * 也可以为每一种汽车写一个单独的方法
 */
class CarFactory2{
    /**
     * 简单工厂一般加上static方便访问
     * 通过不同类型获得不同的车
     * @param type 类型
     * @return 车
     */
    public static Car createBenz(){
        return new Benz();
    }
    
    public static Car createBmw(){
        return new Bmw();
    }
    
}

public class SampleFactoryTest {

    public static void main(String[] args) {
        //通过工厂创建一个Benz
        //Car benz = CarFactory.createCar("benz");
        //Car bmw = CarFactory.createCar("bmw");
        Car benz = CarFactory2.createBenz();
        Car bmw = CarFactory2.createBmw();
        //调用者调用run方法
        benz.run();
        bmw.run();
    }
}

到这里一个简单工厂的实现已经完成，但是现在会有一个新的问题，当你要新增Car的时候，势必要去修改工厂方法来适应新的需求，这样便破坏了Open-closed Principle，下面是修改后的：

interface Car{
    
    public void run();
}

class Benz implements Car{

    @Override
    public void run() {
        System.out.println("奔驰在跑...");
    }
    
}

class Bmw implements Car{

    @Override
    public void run() {
        System.out.println("宝马在跑...");
    }
    
}
/**
 * 将工厂抽象为接口
 *
 */
interface CarFactory{
    Car createCar();
}
/**
 * 奔驰工厂
 *
 */
class BenzFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new Benz();
    }
    
}

/**
 * 宝马工厂
 *
 */
class BmwFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new Bmw();
    }
    
}


public class SampleFactoryTest {

    public static void main(String[] args) {
        
        //通过工厂创建对象
        Car benz = new BenzFactory().createCar();
        Car bmw = new BmwFactory().createCar();
        //调用者调用run方法
        benz.run();
        bmw.run();
    }
}

以上就是工厂方法模式，和简单工厂略有不同，通过抽象工厂为接口解决了OCP，现在的这个工厂变得更好扩展了，但其实这种写法复杂了很多，还是看你怎么取舍了吧。