SimpleFactory
说到工厂，我们应该能想到，造汽车的有汽车工厂，造轮船的有轮船工厂，映射到Java中，造对象的就应该有对象工厂，比如说我想要买一辆车，那我只需要去汽车工厂（先不去4S店）里面告诉它什么品牌的汽车，具体参数，给钱提车就完了，我并不需要了解汽车是如何造出来的，也就是屏蔽了造车的细节，这样的好处就是对于买家来说，简单方便，用户体验大大提升，对于卖家来说我厂生产汽车的具体细节不会外露。
需求：
用户提出要圆形、三角形、菱形等等。
解决方案1：
public void m1() {
// 用户需要圆，自己new一个
Circle circle = new Circle();
// 用户需要三角形，自己new一个
Triangle triangle = new Triangle();
}
解决方案2：
可以使用简单工厂的模式，只需要将工厂暴露给调用方，调用方给出自己想要的形状就可以了，因为所有的设计模式都是面向接口编程，所以接口是少不了的。
定义一个Shape接口
/**
* Description: 所有图形都有的公共属性，定义成抽象类也可以，接口也可
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/7
* @Since v1.0
*/
public interface Shape {
void draw();
}
Shape接口的实现类CricleShape
/**
* Description: 圆形实例
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/7
* @Since v1.0
*/
public class CircleShape implements Shape {
public CircleShape() {
System.out.println("圆形创建出来。");
}
@Override
public void draw() {
System.out.println("画出一个圆形。");
}
}
Shape接口的实现类Triangle
/**
* Description: 三角形实例
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/7
* @Since v1.0
*/
public class TriangleShape implements Shape {
public TriangleShape() {
System.out.println("三角形创建出来。");
}
@Override
public void draw() {
System.out.println("画出一个三角形");
}
}
简单工厂类，对外暴露方法
/**
* Description: 简单工厂类
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/7
* @Since v1.0
*/
public class ShapeFactory {
/**
* 1. 简单工厂模式对外屏蔽了对象的创建细节，需要什么对象直接从工厂获取。
* 2. 将获取对象的方法声明成静态的，由工厂类，向外提供服务。
*/
public static Shape getShape(String shapeName) {
Shape shape = null;
if (null != shapeName && !"".equals(shapeName)) {
if ("circle".equalsIgnoreCase(shapeName)) {
shape = new CircleShape();
} else if ("triangle".equalsIgnoreCase(shapeName)) {
shape = new TriangleShape();
}
}
return shape;
}
}
测试类
在调用方只需要给工厂提供想要的形状即可，不必关心形状是如何来的。
/**
* Description: 简单工厂模式测试用例
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/7
* @Since v1.0
*/
public class Test01 {
@Test
public void m1() {
Shape circle = ShapeFactory.getShape("circle");
circle.draw();
}
}
简单工厂，根本来说不属于23中设计模式中的一种，但工厂方法模式和抽象工厂模式都是由它演变来的，它的缺点：系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂，违背了OCP原则。
FactoryMethod
还是上面的汽车例子，简单工厂类中维护了创建不同汽车的逻辑，比如说包括宝马，奔驰，奥迪，但后续需求越来越多，又增添了长城，马自达，大众等等品牌，那么这个工厂类的创建逻辑会越来越多，现实中，宝马有宝马自己的工厂，奔驰也有奔驰自己的工厂，映射到Java中，不同的类，应该有各自的工厂，这样的目的就是为了维护扩展方便，同时遵循了OCP原则。
设计模式是基于接口的，首先要有一个汽车的接口Car，它用来规定汽车的公共功能：
/**
* Description: 所有汽车的公共接口
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface Car {
/**
* car在跑。
*/
void running();
}
然后是具体品牌汽车的实例：
宝马：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BaoMa implements Car {
@Override
public void running() {
System.out.println("宝马飞驰。");
}
}
奔驰：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BenChi implements Car {
@Override
public void running() {
System.out.println("奔驰奔跑。");
}
}
然后是各自品牌的工厂，在创建各自工厂之前，最好加一层汽车工厂接口，目的是用多态来返回不同的工厂，使代码更加灵活。
汽车工厂接口：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface CarFactory {
Car createCar();
}
各自的汽车工厂类：
宝马工厂：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BaoMaFactory implements CarFactory {
@Override
public Car createCar() {
System.out.println("宝马工厂生产汽车。");
return new BaoMa();
}
}
奔驰工厂：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BenChiFactory implements CarFactory {
@Override
public Car createCar() {
System.out.println("奔驰工厂生产汽车。");
return new BenChi();
}
}
测试类：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class Test01 {
@Test
public void m1() {
// 1. 先获取宝马车的工厂，如果想改奔驰的，仅改动一行代码即可。
CarFactory carFactory = new BaoMaFactory();
// 2. 利用工厂来制造汽车
Car car = carFactory.createCar();
car.running();
}
}
工厂方法模式就很利于扩展，且不需要改动原来的代码，不管增加多少个品牌，只需要增加对应的工厂，以及实例就好了。
适用场景：
- 客户端不需要知道它所创建的对象的类。例子中我们不知道每个汽车具体叫什么名，只知道创建它的工厂名就完成了创建过程。
- 客户端可以通过子类来指定创建对应的对象。
AbstractFactory
抽象工厂的局限性比较大，并且它不符合OCP原则，工厂方法模式是创建一个对象，而抽象工厂它可以创建一组对象，这是和工厂方法模式最大的不同点。上述汽车的例子，假如汽车生产出来，出厂之前，我还需要给汽车做一个包装保养的服务，比如宝马有宝马的包装保养，奔驰有奔驰的包装保养，那是不是应该再创建一个专门做保养的工厂呢，肯定不是，抽象工厂的作用就是将汽车的生产、保养，以及后续的任务都做到一起，秉承一条龙服务，包括汽车的生产，包装，保养，维修等。
首先定义基本接口：
- 汽车公共接口Car：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface Car {
/**
* car在跑。
*/
void running();
}
- 汽车维修服务接口CarFix：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface CarFix {
/**
* 汽车维修服务
*/
void carFix(Car car);
}
- 汽车包装服务接口CarPack：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface CarPack {
/**
* 汽车包装服务
*/
void carPack(Car car);
}
三个接口的实现类：
- Car类
宝马BaoMa：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BaoMa implements Car {
@Override
public void running() {
System.out.println("宝马飞驰。");
}
}
奔驰BenChi：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BenChi implements Car {
@Override
public void running() {
System.out.println("奔驰奔跑。");
}
}
- 维修类CarFixService：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class CarFixService implements CarFix {
@Override
public void carFix(Car car) {
System.out.println(car.getClass() + "在维修。");
}
}
- 包装类CarPackService：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class CarPackService implements CarPack {
@Override
public void carPack(Car car) {
System.out.println(car.getClass() + "精美包装。");
}
}
抽象工厂：
抽象工厂中提供了此工厂所有的服务以及功能，包括汽车生产、包装、维修等。
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public interface AbstractFactory {
/**
* 汽车创造
*/
Car createCar();
/**
* 汽车修理服务
*/
CarFix carFix(Car car);
/**
* 汽车包装服务
*/
CarPack carPack(Car car);
}
具体的汽车工厂：
奔驰工厂BenChiFactory：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BenChiFactory implements AbstractFactory {
@Override
public Car createCar() {
return new BenChi();
}
@Override
public CarFix carFix(Car car) {
return new CarFixService();
}
@Override
public CarPack carPack(Car car) {
return new CarPackService();
}
}
宝马工厂BaoMaFactory：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class BaoMaFactory implements AbstractFactory {
@Override
public Car createCar() {
return new BaoMa();
}
@Override
public CarFix carFix(Car car) {
return new CarFixService();
}
@Override
public CarPack carPack(Car car) {
return new CarPackService();
}
}
测试类：
/**
* Description:
* @From www.zhangjianbing.com
* @Author 70KG
* @Date 2019/3/11
* @Since v1.0
*/
public class Test01 {
@Test
public void m1() {
// 1. 先按名字获取工厂
AbstractFactory factory = new BenChiFactory();
// 2. 生产车
Car car = factory.createCar();
// 3. 包装车
CarPack carPack = factory.carPack(car);
carPack.carPack(car);
// 4. 上路
car.running();
// 5. 修理车
CarFix carFix = factory.carFix(car);
carFix.carFix(car);
// -- 以上全部都是由工厂来完成。
}
}
测试结果：
生产奔驰。
BenChi精美包装。
奔驰奔跑。
BenChi在维修。
抽象工厂适用场景：
- 和工厂方法一样客户端不需要知道它所创建的对象的类。
- 需要一组对象共同完成某种功能时。并且可能存在多组对象完成不同功能的情况。
- 系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）