分析简单工厂模式中的合同签署案例,已产品为维度,创建工厂类,根据信息不同使用工厂类创建不同的产品对象,假设增加维度呢,是不是要创建第二个简单工厂,假设增加是个维度呢?,不容易扩展,
客户签署合同,产品AAA,产品BBB分别签署"甲方合同",“乙方合同”,会出现四种情况,A产品签署甲方合同,签署乙方合同,B产品签署甲方合同,签署乙方合同,一共两个维度,产品种类,合同种类
//产品抽象接口
interface ProductInterface{
//获取产品类型
String getProductType();
//获取合同类型
String getContractType();
//业务代码
void testRun();
}
//产品A甲方合同
class ProductAContractA implements ProductInterface{
private String productType = "AAA";
private String contractType = "甲方";
@Override
public String getProductType() {
return productType;
}
@Override
public String getContractType() {
return contractType;
}
@Override
public void testRun() {
System.out.println("产品AAA签署甲方合同业务代码执行");
}
}
//产品A乙方合同
class ProductAContractB implements ProductInterface{
private String productType = "AAA";
private String contractType = "乙方";
@Override
public String getProductType() {
return productType;
}
@Override
public String getContractType() {
return contractType;
}
@Override
public void testRun() {
System.out.println("产品AAA签署乙方合同业务代码执行");
}
}
//产品B甲方合同
class ProductBContractA implements ProductInterface{
private String productType = "AAA";
private String contractType = "乙方";
@Override
public String getProductType() {
return productType;
}
@Override
public String getContractType() {
return contractType;
}
@Override
public void testRun() {
System.out.println("产品AAA签署乙方合同业务代码执行");
}
}
//产品B乙方合同
class ProductBContractB implements ProductInterface{
private String productType="BBB";
private String contractType = "乙方";
@Override
public String getProductType() {
return productType;
}
@Override
public String getContractType() {
return contractType;
}
@Override
public void testRun() {
System.out.println("产品BBB签署乙方合同业务代码执行");
}
//创建抽象工厂,将根据信息创建出对象,对应信息不同的业务代码,下沉到子类工厂
abstract class ProductFactory{
//根据产品创建对应的具体产品
abstract ProductInterface createProductContract(String productType);
//通过Contract签署合同
public static void contractSign(ProductInterface Product){
Contract.sign(Product);
}
}
//有多个维度,根据某个维度创建工厂,例如此处有合同类型与产品两个维度,甲方乙方,产品A,产品B,
//根据合同类型创建工厂,一个工厂代表一个合同类型,在工厂中判断产品种类,获取到两个信息,
//得到结构,进行业务处理
//创建工厂子类A
class ProductContractFactoryA extends ProductFactory{
//根据传递的产品类型创建出Product对象
@Override
public ProductInterface createProductContract(String productType) {
ProductInterface product = null;
if("AAA".equals(productType)){
product = new ProductAContractA();
product.testRun();
}else if("BBB".equals(productType)){
product = new ProductAContractB();
product.testRun();
}else {
System.out.println("没有该产品!");
//抛出异常
}
return product;
}
}
//创建工厂子类B
class ProductContractFactoryB extends ProductFactory{
//根据传递的产品类型创建出Product对象
@Override
public ProductInterface createProductContract(String productType) {
ProductInterface product = null;
if("AAA".equals(productType)){
product = new ProductBContractA();
product.testRun();
}else if("BBB".equals(productType)){
product = new ProductBContractB();
product.testRun();
}else {
System.out.println("没有该产品!");
//抛出异常
}
return product;
}
}
class Contract{
//合同签署代码,业务代码与功能代码进行剥离,使其只关注功能
public static void sign(ProductInterface product){
System.out.println(product.getProductType()+"产品签署"
+product.getContractType()+"合同成功或失败");
}
}
public class FactoryTest {
public static void main(String[] args) {
//根据合同类型创建不同的工厂
//甲方合同工厂(在创建工厂时,就已经确定了一个维度)
ProductFactory factoryA = new ProductContractFactoryA();
//乙方合同工厂
ProductFactory factoryB = new ProductContractFactoryB();
//通过工厂创建出需要的对象
//甲方合同AAA产品(再给出确定的产品类型,确定第二个维度,通过工厂创建出对象)
ProductInterface productAa = factoryA.createProductContract("AAA");
//执行合同签署
ProductFactory.contractSign(productAa);
//甲方合同BBB产品
ProductInterface productAb = factoryA.createProductContract("BBB");
ProductFactory.contractSign(productAb);
//乙方合同AAA产品
ProductInterface productBa = factoryB.createProductContract("BBB");
ProductFactory.contractSign(productBa);
}
}
工厂方法是为了解决简单工厂违反ocp原则问题而出现的,抽象出父工厂,根据某个维度创建多个子工厂,将创建对象方法下沉到子工厂中,由子工厂去确定创建什么类型的对象,在调用时当能确定由哪个子工厂去执行创建对象,实际已经确定了一个维度,例如创建产品A的子工厂时,已经确定了产品类型,在子工厂中只需要编写确定合同类型的逻辑代码即可,也就是对简单方法的再次抽象,每抽象一次确定一个维度,假设此时需要增加产品类型C,就需要修改子工厂中的逻辑代码,如果增加一个合同类型,就要增加一个子工厂,开发量较大
关键是提供一个产品族（一系列相互依赖的对象）抽象接口，将一系列的产品族统一到一起创建，通过抽象接口创建需要的指定实例，对客户端与实现细节进行解耦
生产美的或者海尔的冰箱，电视
//冰箱
abstract class Refrigerator {
abstract void produceRefrigerator();
}
//电视
abstract class TV {
abstract void produceTV();
}
//海尔冰箱
class HaierRefrigerator extends Refrigerator{
@Override
void produceRefrigerator() {
System.out.println("生产海尔冰箱");
}
}
//海尔电视
class HaierTV extends TV {
@Override
void produceTV() {
System.out.println("生产海尔电视");
}
}
//美的冰箱
class MideaRefrigerator extends Refrigerator{
@Override
void produceRefrigerator() {
System.out.println("生产美的冰箱");
}
}
//美的电视
class MideaTV extends TV {
@Override
void produceTV() {
System.out.println("生产美的电视");
}
}
//公共的抽象工厂
interface ElectricFactory{
//生产冰箱
Refrigerator getRefrigerator();
//生产电视
TV getTV();
}
//美的产品族,工厂子类, 该产品族下生产美的品牌的电器,
class MideaFactory implements ElectricFactory {
//创建美的冰箱逻辑方法
@Override
public Refrigerator getRefrigerator() {
return new MideaRefrigerator();
}
//创建美的电视逻辑方法
@Override
public TV getTV() {
return new MideaTV();
}
}
//海尔产品族,生产海尔品牌电器
class HaierFactory implements ElectricFactory {
//创建海尔冰箱逻辑方法
@Override
public Refrigerator getRefrigerator() {
return new HaierRefrigerator();
}
//创建海尔电视逻辑方法
@Override
public TV getTV() {
return new HaierTV();
}
}
public class FactoryTest {
public static void main(String[] args) {
//抽象工厂,通过后面的new MideaFactory(),
//可以看出创建的是美的产品族中的产品
ElectricFactory mFactory= new MideaFactory();
Refrigerator mRefrigerator = mFactory.getRefrigerator();
mRefrigerator.produceRefrigerator();
//创建海尔产品族,通过海尔产品族创建指定产品
ElectricFactory hFactory= new HaierFactory();
TV hRTV = hFactory.getTV();
hRTV.produceTV();
}
}
