一、解决了什么问题？
可批量生产、达到标注化。解决用户和产品之间的关系。
对于调用者来说不关心产生的具体逻辑，只关心结果；而对于工厂来说，保证我们产生出来的结果是符合国际化标准的。
工厂模式：只对结果负责，确保产品的标准化。
二、工厂模式演变过程，及代码实现demo
三、源-简单工厂
Car.java
package com.demo.gc;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:27
* @description: 定义标准（类）
*/
public interface Car {
/**
* 获取一个标准的产品
* @return
*/
String getCarName();
}
BmCar.java
package com.demo.gc;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:41
* @description:
*/
public class BmCar implements Car {
@Override
public StringgetCarName() {
return "宝马";
}
}
BcCar .java
package com.demo.gc;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:30
* @description:
*/
public class BcCar implements Car {
@Override
public String getCarName() {
return "奔驰";
}
}
SimpleFactory.java
package com.demo.gc.simple;
import com.demo.gc.BcCar;
import com.demo.gc.BmCar;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:33
* @description:
*/
public class SimpleFactory {
public String getCarName(String type){
if("BC".equals(type)){
return new BcCar().getCarName();
}else if("BM".equals(type)){
return new BmCar().getCarName();
}else {
return "未找到该汽车生成的工厂，无法产出该汽车";
}
}
}
Test.java
package com.demo.gc.simple;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:08
* @description: 简单工厂模式
*/
public class Test {
public static void main(String[] args) {
//用户本身不关心生产的过程，而只需要关心最后的结果
//得到一个工厂
SimpleFactory simpleFactory=new SimpleFactory();
System.out.println(simpleFactory.getCarName("BC"));
System.out.println(simpleFactory.getCarName("BM"));
System.out.println(simpleFactory.getCarName("DC"));
}
}
总结一：
- 优点
- 通过一个含参的工厂方法，我们可以实例化任何产品类；
- 缺点
- 当我们的子类比较多的情况下，SimpleFactory里面的代码会非常的多；
- 遵循开闭原则的情况下，不能扩展（简直难受）；
四、针对简单工厂的缺点---工厂模式
Factory.java
package com.demo.gc.func;
import com.demo.gc.Car;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:47
* @description: 工厂方法模式
*/
public interface Factory {
//工厂必定会有一个生产的功能
Car getCarName();
}
BcCarFactory.java
package com.demo.gc.func;
import com.demo.gc.BcCar;
import com.demo.gc.Car;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:57
* @description:
*/
public class BcCarFactory implements Factory {
@Override
public Car getCarName() {
return new BcCar();
}
}
BmCarFactory.java
package com.demo.gc.func;
import com.demo.gc.BmCar;
import com.demo.gc.Car;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:57
* @description:
*/
public class BmCarFactory implements Factory {
@Override
public Car getCarName() {
return new BmCar();
}
}
Test.java
package com.demo.gc.func;
/**
* @ather: lucksheep
* @date: 2018/8/6 16:48
* @description: 工厂模式
*/
public class Test {
public static void main(String[] args) {
Factory factory=new BmCarFactory();
System.out.println(factory.getCarName().getCarName());
}
}
总结二：
- 优点
- 工厂方法模式减轻了工厂类的负担；
- 方便扩展，使工厂类遵循开放-开闭原则；
- 缺点
- 相比简单工厂，实现稍微复杂点，处理起来也复杂了很多；
五、针对抽象方法模式缺点---抽象工厂模式
CarFactory.java
package com.demo.gc.abstr;
import com.demo.gc.BcCar;
import com.demo.gc.BmCar;
import com.demo.gc.Car;
/**
* @ather: zhouyang
* @date: 2018/8/6 17:05
* @description:
*/
public class CarFactory extends AbstractFactory {
@Override
public Car getBmCar() {
return new BmCar();
}
@Override
public Car getBcCar() {
return new BcCar();
}
}
AbstractFactory.java
package com.demo.gc.abstr;
import com.demo.gc.Car;
/**
* @ather: zhouyang
* @date: 2018/8/6 17:00
* @description: 抽项工厂模式
*/
public abstract class AbstractFactory {
//方便于统一的管理
//与接口的区别，不仅仅只有接口的功能，还有抽象的逻辑；接口只是一接口
/**
* 获取bmCar
* @return
*/
public abstract Car getBmCar();
/**
* 获取bcCar
* @return
*/
public abstract Car getBcCar();
}
Test.java
package com.demo.gc.abstr;
/**
* @ather: lucksheep
* @date: 2018/8/6 17:04
* @description:
*/
public class Test {
public static void main(String[] args) {
CarFactory factory=new CarFactory();
System.out.println(factory.getBcCar().getCarName());
System.out.println(factory.getBmCar().getCarName());
}
}
六：区别
- 简单工厂：在同级结构里面可生产任意产品，在遵循开闭原则的情况下，不支持扩展
- 工厂方法：在同级结构里面只能生产固定的产品，在遵循开闭原则的情况下，支持拓展
- 抽象工厂：用来产出所有产品