设计模式学习笔记之工厂模式

工厂模式一般有三种：简单工厂，工厂方法，抽象工厂

定义：

简单工厂：简单工厂模式又称静态工厂方法模式，定义一个用于创建对象的接口。 

工厂方法：定义了一个创建对象的接口，但由于子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

抽象工厂：提供一个抽象接口用来用来创建一个产品家族。

工厂模式依赖的原则：

依赖导致原则（要依赖抽象，不要依赖具体类）。这个原则听起来很像“针对接口编程，不针对实现编程”。这个原则说明了：不能让高层组件依赖底层组件，而且不管高层或底层组件，两者都应该依赖抽象。

对扩展开放，对修改关闭

简单工厂：

实例：

一个car有几个子类，有一个工厂创建不同的car实例

public class StaticCarFactory {  
    // 静态工厂  
    public static Car createCar(String type) {  
        if ("bmwx3".equals(type)) {  
            return new BmwX3Car();  
        } else if ("bmwx5".equals(type)) {  
            return new BmwX5Car();  
        } else if ("bmwx7".equals(type)) {  
            return new BmwX7Car();  
        } else  
            return null;  
    }  
}  
public class CarSalesShop {  
    public Car orderCar(String type) {  
        Car car = StaticCarFactory.createCar(type);// 通过工厂类，根据type创建一个Car实例
        car.prepare();  
        car.fabricate();  
        car.detect();  
  
        System.out.println("A " + car.getName() + " car is ready.");  
        return car;  
    }  
} 

工厂方法：

工厂方法让类把实例化推迟到子类，让子类决定要实例化的类是哪一个。

工厂模式好处：将创建对象代码集中在一个对象或方法中，可以避免代码中的重复，并且更方便以后的维护。这也意味着客户在实例化对象时，只会依赖于接口，而不是具体类。这可以使的代码针对接口编程，而不是针对实现编程。者让代码更具有弹性，可应对未来的扩展。

实例：

还是以上Car的实例，不过多同的地区所卖的不同类型的车是不同的，假设有上海，北京两个地区的car shop

public abstract class CarSalesShop {  
    public Car orderCar(String type) {  
        Car car = createCar(type);  
        car.prepare();  
        car.fabricate();  
        car.detect();  
        System.out.println("A " + car.getName() + " car is ready.");  
        return car;  
    }  
  
    // 工厂方法接口  
    public abstract Car createCar(String type);  
}  
  
public class BeijingCarSalesShop extends CarSalesShop {  
    @Override  
    public Car createCar(String type) {  
        if ("bmwx3".equals(type)) {  
            return new BeijingBmwX3Car();  
        } else if ("bmwx5".equals(type)) {  
            return new BeijingBmwX5Car();  
        } else if ("bmwx7".equals(type)) {  
            return new BeijingBmwX7Car();  
        } else  
            return null;  
    }  
}  
  
public class ShanghaiCarSalesShop extends CarSalesShop {  
    @Override  
    public Car createCar(String type) {  
        if ("bmwx3".equals(type)) {  
            return new ShanghaiBmwX3Car();  
        } else if ("bmwx5".equals(type)) {  
            return new ShanghaiBmwX5Car();  
        } else if ("bmwx7".equals(type)) {  
            return new ShanghaiBmwX7Car();  
        } else  
            return null;  
    }  
}  

抽象工厂：

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

实例：假设每个地区的car需要本地区的不同的零件，通过一个工厂家族

// 汽车零件制造工厂  
public interface PartsFactory {  
    public Engine createEngine();  
  
    public Wheel createWheel();  
    //这里相当于一个工厂方法
    public Lamp createLamp();  

}  
  
public class BeijingPartsFactory implements PartsFactory {  
    public Engine createEngine() {  
        return new BeijingEngine();  
    }  
  
    public Lamp createLamp() {  
        return new BeijingLamp();  
    }  
  
    public Wheel createWheel() {  
        return new BeijingWheel();  
    }  
}  
  
public class ShanghaiPartsFactory implements PartsFactory {  
    public Engine createEngine() {  
        return new ShanghaiEngine();  
    }  
  
    public Lamp createLamp() {  
        return new ShanghaiLamp();  
    }  
  
    public Wheel createWheel() {  
        return new ShanghaiWheel();  
    }  
}  

比较工厂方法和抽象工厂：

工厂方法：提供了一个抽象接口（通常是一个抽象方法）来创建“一个产品”

每一个子类来“决定”实例化哪个“具体类”

抽象工厂：提供一个抽象接口用来用来创建一个产品家族。

因为我们需要创建一个产品家族，我们需要把原料（书籍上pizza实例）实现一个抽象工厂。每一个子类都使用其区域供货商来实现这些原料。

每一个具体子类都创建一个家族产品，这个负责在抽象工厂中创建产品的方法，通常是以“工厂方法”来实现的（抽象接口中有多个抽象方法，每一个抽象方法相当于一个工厂方法，用于创建家族产品中的一个产品）。