java工程师面试高频考点之工厂模式

Posted 小牛儿帥

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java工程师面试高频考点之工厂模式相关的知识，希望对你有一定的参考价值。

在这里插入图片描述

工厂模式

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。
按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。
我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”
在这里插入图片描述

简单工厂模式

简介：

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

举个实际的例子来方便大家的理解，在生活中不论做什么都存在一定的流程或者是一种先后顺序，比如说农村从种植农作物开始到收割处理掉的整个过程，可以看作是农耕社会小作坊（简单工厂，民间的面坊、酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。我们的项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单。
所以在日常的开发过程中，凡是遇到需生成复杂对象的地方，可以尝试采用工厂模式来实现。

注意：上述复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。

简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。
** 优点和缺点**
优点：
工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。
缺点：
简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。
应用场景
对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

模式结构与实现

简单工厂模式的主要模块如下：

  • 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
  • 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
  • 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

结构如下图：
在这里插入图片描述

在这里插入图片描述
实现代码如下：

   public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

	        //抽象产品
	        public interface CashSuper{
	            void acceptCash();
	        }
	        static class CashNorman1 implements CashSuper {
	            public void acceptCash() {
	                System.out.println("生产产品");
	            }
	        }
	        static class CashRebate implements CashSuper {
	            public void acceptCash() {
	                System.out.println("回扣产品");
	            }
	        }
	        static class CashReturn implements CashSuper {
	            public void acceptCash() {
	                System.out.println("返回产品");
	            }
	        }
	        final class Const {
	            static final int PRODUCT_A = 0;
	            static final int PRODUCT_B = 1;
	            static final int PRODUCT_C = 2;
	        }
	        static class CashFactory {
	            public static CashSuper CreateCashFactory(int kind) {
	                switch (kind) {
	                    case Const.PRODUCT_A:
	                        return new CashNorman1();
	                    case Const.PRODUCT_B:
	                        return new CashRebate();
	                    case Const.PRODUCT_C:
	                        return new CashReturn();
	                }
	                return null;
	            }
	        }
	    }

生产结果显示：
在这里插入图片描述

工厂方法模式

在这里插入图片描述
简单工厂模式违背了开闭原则，每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，增加了复杂度。而工厂方法则是在简单工厂模式的进一步抽象化，好处在于不修改原来代码的情况下引进新的产品，满足开闭原则。

在现实生活中社会分工越来越细，越来越专业化。各种产品有专门的工厂生产，彻底告别了自给自足的小农经济时代，这大大缩短了产品的生产周期，提高了生产效率。同样，在软件开发中能否做到软件对象的生产和使用相分离呢？能否在满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用呢？

工厂方法的优点：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
  • 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
  • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

工厂方法的缺点：

  • 类的个数容易过多，增加复杂度
  • 增加了系统的抽象性和理解难度
  • 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景

  • 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
  • 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
  • 客户不关心创建产品的细节，只关心产品的品牌

模式的结构与实现：
工厂方法模式的主要角色如下。

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
  • 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

结构如下图：
在这里插入图片描述
代码实现：

package model_23;

public class AbstractFactoryTest {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		try {
			Product p;
			AbstractFactory af;
			af =new ConcreateFactory1();
			p = af.newProduct();
			p.show();
		}catch (Exception e){
			System.out.println(e.getMessage());
		}
	}
	 interface Product{
		void show();
	}
	static class ConcreteProduct1 implements Product{

		@Override
		public void show() {
			// TODO 自动生成的方法存根
			System.out.println("生产产品1号！");
		}
		
	}
	static class ConcreteProduct2 implements Product{

		@Override
		public void show() {
			// TODO 自动生成的方法存根
			System.out.println("生产产品2号！");
		}
		
	}
	
	interface AbstractFactory{
		Product newProduct();
	}
	static class ConcreateFactory1 implements AbstractFactory{

		@Override
		public Product newProduct() {
			// TODO 自动生成的方法存根
			System.out.println("具体工厂1生成-->具体产品1...");
			return new ConcreteProduct1();
		}
		
	}
	static class ConcreateFactory2 implements AbstractFactory{

		@Override
		public Product newProduct() {
			// TODO 自动生成的方法存根
			System.out.println("具体工厂2生成-->具体产品2...");
			return new ConcreteProduct2();
		}
		
	}
}

结果如下：
在这里插入图片描述

抽象工厂模式

抽象工厂模式是在工厂方法模式上的进一步更改，考虑多级产品的生产，将同一个工厂所生产的位于不同等级的一组产品称为产品族。
在这里插入图片描述

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。
同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

抽象工厂模式的定义与特点：

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品，系统一次只能消耗其中某一族产品，即同族的产品一起使用。
优点：

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点：

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

抽象工厂的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

1.模式结构

  1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
  2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
  3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
    在这里插入图片描述
    在这里插入图片描述

2.模式的实现

package model_23;

public class AbstractFactorys {
	public static void main(String[] args) {
		AbstractFactory abs=new ConcreteFactory1();//声明实例工厂1
		ConcreteProduct11 con=(ConcreteProduct11) abs.newProduct1();//生产该工厂的第一类型产品
		con.show();
	}

	 interface Product1{
			void show();
		}
	 interface Product2{
			void show();
		}
		 //具体产品1
		static class ConcreteProduct11 implements Product1{

			@Override
			public void show() {
				// TODO 自动生成的方法存根
				System.out.println("生产产品11号");
			}
			
		}
		static class ConcreteProduct12 implements Product1{

			@Override
			public void show() {
				// TODO 自动生成的方法存根
				System.out.println("生产产品12号");
			}
			
		}
		//具体产品2
		static class ConcreteProduct21 implements Product2{

			@Override
			public void show() {
				// TODO 自动生成的方法存根
				System.out.println("生产产品21号");
			}
			
		}
		static class ConcreteProduct22 implements Product2{

			@Override
			public void show() {
				// TODO 自动生成的方法存根
				System.out.println("生产产品22号");
			}
			
		}
		
		static	interface AbstractFactory{//抽象工厂
			public Product1 newProduct1();
			public Product2 newProduct2();
		}
		//具体工厂1
		static		class ConcreteFactory1 implements AbstractFactory {
		    public Product1 newProduct1() {
		        System.out.println("具体工厂 1 生成-->具体产品 11...");
		        return new ConcreteProduct11();
		    }
		    public Product2 newProduct2() {
		        System.out.println("具体工厂 2 生成-->具体产品 21...");
		        return new ConcreteProduct21();
		    }
		}
		//具体工厂2
	static	class ConcreteFactory2 implements AbstractFactory {
		    public Product1 newProduct1() {
		        System.out.println("具体工厂 1生成-->具体产品 12...");
		        return new ConcreteProduct12();
		    }
		    public Product2 newProduct2() {
		        System.out.println("具体工厂 2 生成-->具体产品 22...");
		        return new ConcreteProduct22();
		    }
		}

}

结果：
在这里插入图片描述

以上是关于java工程师面试高频考点之工厂模式的主要内容，如果未能解决你的问题，请参考以下文章

java工程师面试高频考点之类的加载顺序

java工程师面试高频考点之内部类

面试高频Java设计模式-工厂模式

面试高频Java设计模式-工厂模式

面试高频Java设计模式-工厂模式

大数据开发面试之26个Spark高频考点