目录

工厂模式

工厂方法模式

抽象工厂

小结

工厂模式

没有使用设计模式之前代码可能是这样的

public class WithoutFactoryPatternDemo {public static void main(String[] args) {Product product1=new Product("产品1");System.out.println(product1);}public static class Product {private String name;public Product(String name) {super();this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Product [name=" + name + "]";}}public static class Product2 {private String name;public Product2(String name) {super();this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Product [name=" + name + "]";}}}

在使用的地方 new出相应的对象, 如果我们需要将Product换成Product2 , 那么所有new 的地方都需要更新, 简直是噩梦, 所以就有了工厂模式的出现来简化这种场景带来的问题

public class FactoryPatternDemo {public static void main(String[] args) {Product product = ProductFactory.create();product.execute();}public interface Product {void execute();}public static class ProductImpl1 implements Product {@Overridepublic void execute() {System.out.print("产品1的功能实现");  }}public static class ProductImpl2 implements Product {@Overridepublic void execute() {System.out.print("产品1的功能实现");  }}public static class ProductFactory {public static Product create() {return new ProductImpl2();}}
}

使用了工厂模式以后, new的地方只有 一个, 如果需要更换类, 更换一个地方就可以

工厂方法模式

不使用模版方法模式, 可能是这样的

public class WithoutFactoryMethodPatternDemo {public static void main(String[] args) {Product product1 = Product1Factory.createProduct();Product product2 = Product2Factory.createProduct();Product product3 = Product3Factory.createProduct();product1.execute();product2.execute();product3.execute();}public interface Product {void execute();}public static class Product1 implements Product {@Overridepublic void execute() {System.out.println("产品1的功能逻辑");}}public static class Product2 implements Product {@Overridepublic void execute() {System.out.println("产品2的功能逻辑");}}public static class Product3 implements Product {@Overridepublic void execute() {System.out.println("产品3的功能逻辑");}}public static class Product1Factory {public static Product createProduct() {System.out.println("生产产品的通用逻辑，修改");  System.out.println("生产产品1的特殊逻辑");return new Product1();}}public static class Product2Factory {public static Product createProduct() {System.out.println("生产产品的通用逻辑，修改");  System.out.println("生产产品2的特殊逻辑");return new Product2();}}public static class Product3Factory {public static Product createProduct() {System.out.println("生产产品的通用逻辑");  System.out.println("生产产品3的特殊逻辑");return new Product3();}}
}

很明显是工厂模式, 但是有问题,  那就是每个构造方法里面 都有相同的逻辑代码, 如果需要修改这段代码, 那么所有的地方都需要改,  工厂方法模式就是来改变这种状况

实现方式就是将工厂方法抽取出抽象类, 然后在构造流程上将公共的部分抽取到抽象类中

public static void main(String[] args) {Product product1 = Product1Factory.get().createProduct();Product product2 = Product2Factory.get().createProduct();Product product3 = Product3Factory.get().createProduct();product1.execute();product2.execute();product3.execute();}public interface Product {void execute();}public static class Product1 implements Product {@Overridepublic void execute() {System.out.println("产品1的功能逻辑");}}public static class Product2 implements Product {@Overridepublic void execute() {System.out.println("产品2的功能逻辑");}}public static class Product3 implements Product {@Overridepublic void execute() {System.out.println("产品3的功能逻辑");}}public static abstract class AbstractProductFactory {public Product createProduct() {commonCreate();return specificCreate();}private void commonCreate() {System.out.println("生产产品的通用逻辑，修改");  }protected abstract Product specificCreate();}public static class Product1Factory extends AbstractProductFactory {private static final Product1Factory instance = new Product1Factory();private Product1Factory() {}public static Product1Factory get() {return instance;}@Overridepublic Product specificCreate() {System.out.println("生产产品1的特殊逻辑");return new Product1();}}public static class Product2Factory extends AbstractProductFactory {private static final Product2Factory instance = new Product2Factory();private Product2Factory() {}public static Product2Factory get() {return instance;}@Overridepublic Product specificCreate() {System.out.println("生产产品2的特殊逻辑");return new Product2();}}public static class Product3Factory extends AbstractProductFactory {private static final Product3Factory instance = new Product3Factory();private Product3Factory() {}public static Product3Factory get() {return instance;}@Overridepublic Product specificCreate() {System.out.println("生产产品3的特殊逻辑");return new Product3();}}}

抽象工厂

不使用抽象工厂可能是这样

public class WithoutAbstractFactoryPatternDemo {public static void main(String[] args) {// 我们现在要创建产品A1+产品B1的组合
//		ProductA productA1 = new ProductA1();
//		ProductB productB1 = new ProductB1();
//		
//		productA1.execute();
//		productB1.execute();// 变成产品A1+产品B3的组合ProductA productA1 = new ProductA1();ProductB otherProductB3 = new ProductB3();productA1.execute();otherProductB3.execute();// 我们现在要创建产品A2+产品B2的组合ProductA productA2 = new ProductA2();ProductB productB2 = new ProductB2();productA2.execute();productB2.execute();// 我们现在要创建产品A3+产品B3的组合ProductA productA3 = new ProductA3();ProductB productB3 = new ProductB3();productA3.execute();productB3.execute();}public interface ProductA {void execute();}public static class ProductA1 implements ProductA {@Overridepublic void execute() {System.out.println("产品A1的功能逻辑");}}public static class ProductA2 implements ProductA {@Overridepublic void execute() {System.out.println("产品A2的功能逻辑");}}public static class ProductA3 implements ProductA {@Overridepublic void execute() {System.out.println("产品A3的功能逻辑");}}public interface ProductB {void execute();}public static class ProductB1 implements ProductB {@Overridepublic void execute() {System.out.println("产品B1的功能逻辑");}}public static class ProductB2 implements ProductB {@Overridepublic void execute() {System.out.println("产品B2的功能逻辑");}}public static class ProductB3 implements ProductB {@Overridepublic void execute() {System.out.println("产品B3的功能逻辑");}}}

问题是，调整产品组合的这个行为，如果你手动创建产品组合的代码，有100个地方，A1+B1
一旦要调整，就是要对100个地方的代码，手动一点一点的去修改，组合的逻辑
不可维护，不可扩展,  于是抽象方法模式,解决这个问题, 将组合抽象到一个工厂中

public class AbstractFactoryPatternDemo {public static void main(String[] args) {// 产品A1+产品B1 -> 产品A1+产品B3ProductA firstProductA = Factory1.get().createProductA();ProductB firstProductB = Factory1.get().createProductB();firstProductA.execute();firstProductB.execute();// 产品A2+产品B2ProductA secondProductA = Factory2.get().createProductA();ProductB secondProductB = Factory2.get().createProductB();secondProductA.execute();secondProductB.execute();// 产品A3+产品B3ProductA thirdProductA = Factory3.get().createProductA();ProductB thirdProductB = Factory3.get().createProductB();thirdProductA.execute();thirdProductB.execute();// 哪怕你有100个地方定义了产品组合，要调整组合的逻辑，只要修改一个工厂就可以了}public interface ProductA {void execute();}public static class ProductA1 implements ProductA {@Overridepublic void execute() {System.out.println("产品A1的功能逻辑");}}public static class ProductA2 implements ProductA {@Overridepublic void execute() {System.out.println("产品A2的功能逻辑");}}public static class ProductA3 implements ProductA {@Overridepublic void execute() {System.out.println("产品A3的功能逻辑");}}public interface ProductB {void execute();}public static class ProductB1 implements ProductB {@Overridepublic void execute() {System.out.println("产品B1的功能逻辑");}}public static class ProductB2 implements ProductB {@Overridepublic void execute() {System.out.println("产品B2的功能逻辑");}}public static class ProductB3 implements ProductB {@Overridepublic void execute() {System.out.println("产品B3的功能逻辑");}}public interface Factory {ProductA createProductA();ProductB createProductB();}public static class Factory1 implements Factory {private static final Factory1 instance = new Factory1();private Factory1() {}public static Factory get() {return instance;}@Overridepublic ProductA createProductA() {return new ProductA1();}@Overridepublic ProductB createProductB() {return new ProductB3(); }}public static class Factory2 implements Factory {private static final Factory2 instance = new Factory2();private Factory2() {}public static Factory get() {return instance;}@Overridepublic ProductA createProductA() {return new ProductA2();}@Overridepublic ProductB createProductB() {return new ProductB2(); }}public static class Factory3 implements Factory {private static final Factory3 instance = new Factory3();private Factory3() {}public static Factory get() {return instance;}@Overridepublic ProductA createProductA() {return new ProductA3();}@Overridepublic ProductB createProductB() {return new ProductB3(); }}}

小结

工厂相关的设计模式是创建型的设计模式