概述
工厂模式是为了提供创建对象的方式，无需制定要创建的具体类。
举个例子，假如我是甲方需要制造一辆车，我可以要油车，可以要电车，也可以油电混动车，如果没有工厂，我需要自己找到对应的制造车的方法来制造。
但是有了工厂之后，我不用直接去找对应类型的车的制造方法，我直接告诉工厂我需要什么类型的车，工厂就可以帮助我制造出我想要类型的车。
简单来说，我不用关注工厂是怎么造车的，我只管问工厂要就行了。
工厂模式又包括工厂方法模式，抽象工厂模式，抽象工厂模式实际像是工厂方法模式的PLUS版本，或者像是套娃版本？抽象工厂相当于将工厂作为一个产品，用户可以选择不同的工厂来定义产品的不同属性。
应用场景
当我们不知道选择哪个接口来创建实例，或者需要在不同条件下创建不同实例时。
优点
调用者只需要知道需要创建的对象的名称即可告诉工厂类进行对象的创建。
缺点
每当增加产品，都需要新增一个工厂类和具体实现类，过多造成类爆炸，系统复杂度就高了。
应用实例
E-R图
代码
1. 制造汽车接口
public interface Car {
//创造汽车的抽象方法
void create();
}2. 汽车具体实现类，包括油车，电车，混动
public class OilCar implements Car {
@Override
public void create() {
System.out.println("制造油车");
}
}
public class ElecCar implements Car {
@Override
public void create() {
System.out.println("制造电车");
}
}public class MixCar implements Car {
@Override
public void create() {
System.out.println("制造油电混动车");
}
}
3. 工厂类
public class CarFactory {
//通过判断传入的参数来决定生产什么类型的汽车
public Car createCar(String type){
if("油车".equals(type)){
return new OilCar();
}
if("电车".equals(type)){
return new ElecCar();
}
if("混动车".equals(type)){
return new MixCar();
}
return null;
}
}4. 调用方法
public class main {
public static void main(String[] args) {
//创建工厂对象
CarFactory carFactory = new CarFactory();
//创建汽车对象
Car car1 = carFactory.createCar("油车");
Car car2 = carFactory.createCar("电车");
Car car3 = carFactory.createCar("混动车");
//创建汽车
car1.create();
car2.create();
car3.create();
}
}抽象工厂方法
E-R图
代码
1. 抽象工厂类
public abstract class AbstractFactory {
public abstract Car createCar(String Car);
public abstract Color createColor( String Color);
}2. 工厂实现类
public class CarFactory extends AbstractFactory {
//通过判断传入的参数来决定生产什么类型的汽车
public Car createCar(String type){
if("油车".equals(type)){
return new OilCar();
}
if("电车".equals(type)){
return new ElecCar();
}
if("混动车".equals(type)){
return new MixCar();
}
return null;
}
@Override
public Color createColor(String Color) {
return null;
}
}public class ColorFactory extends AbstractFactory {
@Override
public Car createCar(String Car) {
return null;
}
//通过判断传入的参数来决定生产什么类型的汽车
public Color createColor(String type){
if("红色".equals(type)){
return new Red();
}
if("黄色".equals(type)){
return new Yellow();
}
if("蓝色".equals(type)){
return new Blue();
}
return null;
}
}3. 产品抽象类和实现类
//汽车接口类
public interface Car {
//创造汽车的抽象方法
void createCar();
}
//汽车实现类
public class OilCar implements Car {
@Override
public void createCar() {
System.out.println("制造油车");
}
}
public class ElecCar implements Car {
@Override
public void createCar() {
System.out.println("制造电车");
}
}
public class MixCar implements Car {
@Override
public void createCar() {
System.out.println("制造油电混动车");
}
}//颜色接口类
public interface Color {
void createColor();
}
public class Red implements Color{
@Override
public void createColor() {
System.out.println("红色");
}
}
public class Yellow implements Color{
@Override
public void createColor() {
System.out.println("黄色");
}
}
public class Blue implements Color{
@Override
public void createColor() {
System.out.println("蓝色");
}
}4. 选择工厂对应的工厂
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("汽车")){
return new CarFactory();
} else if(choice.equalsIgnoreCase("颜色")){
return new ColorFactory();
}
return null;
}
}5. 主类调用
public class main {
public static void main(String[] args) {
//创建汽车工厂
AbstractFactory carFactory = FactoryProducer.getFactory("汽车");
Car oilCar = null;
if (carFactory != null) {
oilCar = carFactory.createCar("油车");
}
if (oilCar != null) {
oilCar.createCar();
}
//创建颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("颜色");
Color redColor = null;
if (colorFactory != null) {
redColor = colorFactory.createColor("红色");
}
if (redColor != null) {
redColor.createColor();
}
}
}
