简介：工厂模式大体分为 简单工厂，工厂方法，抽象工厂等三种模式。工厂方法模式也可以称为工厂模式。简单工厂进阶变成工厂方法，然后在进阶成抽象工厂、
简单工厂模式
又叫做静态工厂方法模式，是由一个工厂对象决定创建出哪一种产品的实例，实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品继承自一个父类或接口）的实例
工厂：负责实现创建所有实例的内部逻辑，并提供一个外界调用的方法，创建所需的产品对象
抽象产品：负责描述产品的公共接口
具体产品：描述生产的具体产品
代码
抽象产品类
/**
* @program: Design
* @description: 抽象产品
* @author: czg
* @create: 2020-03-03 20:08
**/
public abstract class Product {
//产品介绍
abstract void intro();
}
具体的产品类 实现了抽象产品类的接口
public class BProduct extends Product{
@Override
void intro() {
System.out.println("雪碧");
}
}
public class AProduct extends Product {
@Override
void intro(){
System.out.println("--可乐--");
}
}
public class CProduct extends Product {
@Override
void intro() {
System.out.println("芬达");
}
}
工厂类 + 测试
public class Factory {
public static void main(String[] args) {
Product a = getProduct("A");
a.intro();
Product b = getProduct("B");
b.intro();
Product c = getProduct("C");
c.intro();
}
/**
* 根据入参 创建相应的对象
* @param type
* @return
*/
public static Product getProduct(String type){
switch (type){
case "A":
return new AProduct();
case "B":
return new BProduct();
case "C":
return new CProduct();
default:
return null;
}
}
}
优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦
缺点：违背了开放-关闭原则 一旦添加新产品就不得不修改工厂类的逻辑，这样会造成工厂类逻辑复杂
工厂方法模式
又称工厂模式，多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而自雷则负责生产具体的对象，一种常用的对象创建设计模式，此模式的核心精神是封装类中不变的部分
作用：将类的实例化延迟到工厂类中完成，即由自雷来决定该实例化哪一个类
抽象工厂：描述具体工厂的公共接口
具体工厂：描述具体工厂，创建产品的实例，供外接调用
抽象产品：负责描述产品的公共接口
具体产品：描述生成的具体产品
代码
抽象产品以及具体产品
public abstract class Product {
abstract void intro();
}
/**
* @program: Design
* @description: 具体产品A
* @author: czg
* @create: 2020-03-03 21:04
**/
public class ProductA extends Product {
@Override
void intro() {
System.out.println("AAAA");
}
}
/**
* @program: Design
* @description: 具体产品B
* @author: czg
* @create: 2020-03-03 21:04
**/
public class ProductB extends Product {
@Override
void intro() {
System.out.println("BBBBBB");
}
}
抽象工厂 具体工厂
public abstract class Factory {
abstract Product getProduct();
}
public class FactoryA extends Factory {
@Override
Product getProduct() {
return new ProductA();
}
}
public class FactoryB extends Factory {
@Override
Product getProduct() {
return new ProductB();
}
}
测试类
public class Test {
public static void main(String[] args) {
FactoryA a = new FactoryA();
a.getProduct().intro();
FactoryB b = new FactoryB();
b.getProduct().intro();
}
}
一个抽象产品可以派生出多个具体产品，一个抽象工厂可以派生出多个具体工厂类，每个具体的工厂只能创建一个具体的产品实例
优点
符合开闭原则：增加一种产品，只需要增加相应的具体产品类和相应的工厂子类即可
符合单一原则：每个工厂类只负责创建对应的产品
缺点
增加了系统的复杂度：类的个数将成对增加
增加了系统的抽象性和理解难度
一个具体的工厂只能创建一种具体的产品
抽象工厂模式
定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类；具体的工厂负责实现具体的产品实例。
抽象工厂模式与工厂模式最大的区别：抽象工厂模式中每个工厂可以创建多种类的产品，而工厂模式每个工厂只能创建一类
抽象工厂：描述具体工厂的公共接口
具体工厂：描述具体工厂，创建产品的实例，供外接调用
抽象产品族：描述抽象产品的公共接口
抽象产品：描述具体产品的公共接口
具体产品：具体产品
代码
抽象产品 抽象产品族 具体产品
//抽象产品类 接口
public abstract class Product {
/**
* 产品介绍
*/
abstract void intro();
}
//抽象产品族
public abstract class ProductA extends Product {
@Override
abstract void intro();
}
public abstract class ProductB extends Product{
@Override
abstract void intro();
}
//具体产品
public class ProductAa extends ProductA {
@Override
void intro() {
System.out.println("农夫山泉");
}
}
public class ProductBb extends ProductB {
@Override
void intro() {
System.out.println("面包");
}
}
抽象工厂 具体工厂
// 抽象工厂
public abstract class Factory {
abstract Product getProductA();
abstract Product getProductB();
}
// 具体工厂
public class FactoryA extends Factory {
@Override
Product getProductA() {
return new ProductAa();
}
@Override
Product getProductB() {
return new ProductBb();
}
}
测试
public class Test {
public static void main(String[] args) {
FactoryA factoryA = new FactoryA();
factoryA.getProductA().intro();
factoryA.getProductB().intro();
}
}
多个抽象产品类，每个抽象的产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出具体工厂类，每个具体工厂类可以创建多个具体产品的实例
优点
降低耦合
符合开闭原则
符合单一职责原则
不适用静态工厂方法，可以形成基于继承的登记结构
缺点
难以扩展新种类产品
总结
简单工厂：具体工厂，抽象产品 具体产品
工厂方法：抽象工厂，具体工厂，抽象产品，具体产品
抽象工厂：抽象工厂，具体工厂，抽象产品族，抽象产品，具体产品
定义
简单工厂：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（继承自一个父类或接口）的实例。 产品得工厂
工厂方法：定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象 工厂的工厂
抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。 复杂产品得工厂