factory method模式：模板方法模式+简单工厂模式，简单工厂模式稍微复杂一点的变种
场景：
（1）我们现在要生产的产品有多种（2）每种产品的生产过程，都有一些是共同的逻辑，但是也有一些是特殊的逻辑（3）现在要生产出来各种产品
1、不使用工厂方法模式
/**
* 不使用设计模式
*/
public class WithoutFactoryMethodPatternDemo {
/**
* 问题在哪儿？
* 跟模板方法模式的问题一样
* 就是多个工厂类中，有生产产品的相同的通用逻辑，没有抽取出来，
* 直接复制粘贴放在多个工厂里了
* 如果那段通用逻辑要修改
* 就需要很麻烦到所有工厂中去修改代码，可能会忘记修改了某个工厂的代码
*/
public static void main(String[] args) {
Product product1 = Product1Factory.creatProduct();
product1.execute();
Product product2 = Product2Factory.creatProduct();
product2.execute();
Product product3 = Product3Factory.creatProduct();
product3.execute();
}
// 产品接口类
public interface Product{
void execute();
}
// 产品接口实现类1
public static class Product1 implements Product{
@Override
public void execute() {
System.out.println("产品1的功能逻辑");
}
}
// 产品接口实现类2
public static class Product2 implements Product{
@Override
public void execute() {
System.out.println("产品2的功能逻辑");
}
}
// 产品接口实现类3
public static class Product3 implements Product{
@Override
public void execute() {
System.out.println("产品2的功能逻辑");
}
}
// 工厂类1
public static class Product1Factory{
public static Product createProduct(){
System.out.println("生产产品的通用逻辑");
System.out.println("生产产品1的特殊逻辑");
return new Product1();
}
}
// 工厂类2
public static class Product2Factory{
public static Product createProduct(){
System.out.println("生产产品的通用逻辑");
System.out.println("生产产品 2 的特殊逻辑");
return new Product2();
}
}
//工厂类3
public static class Product3Factory{
public static Product createProduct(){
System.out.println("生产产品的通用逻辑");
System.out.println("生产产品 3 的特殊逻辑");
return new Product3();
}
}
}
2、使用工厂方法模式
/**
* 使用工厂方法设计模式
*/
public class FactoryMethodPatternDemo {
// 主函数
public static void main(String[] args) {
Product product1 = Product1Factory.get().createProduct();
Product product2 = Product2Factory.get().createProduct();
Product product3 = Product3Factory.get().createProduct();
}
// 产品接口
public interface Product{
void execute();
}
// 产品接口实现类1
public static class Product1 implements Product {
@Override
public void execute() {
System.out.println("产品1的功能逻辑");
}
}
// 产品接口实现类2
public static class Product2 implements Product {
@Override
public void execute() {
System.out.println("产品2的功能逻辑");
}
}
// 产品接口实现类3
public static class Product3 implements Product {
@Override
public void execute() {
System.out.println("产品2的功能逻辑");
}
}
// 抽象工厂
public static abstract class AbstractProductFactory{
public Product createProduct(){
commonCreate();
return specificCreate();
}
private void commonCreate() {
System.out.println("生厂产品通用的步骤");
}
protected abstract Product specificCreate();
}
// 抽象工厂子类1
public static class Product1Factory extends AbstractProductFactory{
private static Product1Factory instance =new Product1Factory();
private Product1Factory() {
}
public static Product1Factory get(){
return instance;
}
@Override
protected Product specificCreate() {
System.out.println("生产产品1的特殊逻辑");
return new Product1();
}
}
// 抽象工厂子类2
public static class Product2Factory extends AbstractProductFactory{
private static Product2Factory instance =new Product2Factory();
private Product2Factory() {
}
public static Product2Factory get(){
return instance;
}
@Override
protected Product specificCreate() {
System.out.println("生产产品 2 的特殊逻辑");
return new Product2();
}
}
// 抽象工厂子类3
public static class Product3Factory extends AbstractProductFactory{
private static Product3Factory instance =new Product3Factory();
private Product3Factory() {
}
public static Product3Factory get(){
return instance;
}
@Override
protected Product specificCreate() {
System.out.println("生产产品 3 的特殊逻辑");
return new Product3();
}
}
}
# 总结
说实话，这种设计模式算是较为复杂一点的了，适用的是比较复杂的场景了
一般就是在有复杂工厂生产场景的情况下，比如就是需要多种工厂生产不同的产品，但是产品都是类似的，同时不同的工厂有一定的相同逻辑，那么就用这种模式
