精华内容
下载资源
问答
  • 工厂方法模式uml类图

    2018-03-07 10:22:41
    java设计模式 工厂方法模式uml类图,一张图就让你秒懂工厂方法模式
  • 工厂方法模式

    万次阅读 2019-05-31 20:40:44
    本章将通过如何克服简单工厂模式的不足来引出工厂方法模式,并通过实例来学习工厂方法模式,理解工厂方法模式的结构及特点,学会如何在实际软件项目开发合理地使用工厂方法模式。 本章知识点 工厂方法模式的定义 ...

    工厂方法模式

    本章导学

    工厂方法模式是简单工厂模式的延伸,它继承了简单工厂模式的优点,同时还弥补了简单工厂模式的缺陷,更好地符合开闭原则的要求,在增加新的具体产品对象时不需要对已有的系统做任何修改。
    本章将通过如何克服简单工厂模式的不足来引出工厂方法模式,并通过实例来学习工厂方法模式,理解工厂方法模式的结构及特点,学会如何在实际软件项目开发合理地使用工厂方法模式。

    本章知识点

    1. 工厂方法模式的定义
    2. 工厂方法模式的结构
    3. 工厂方法模式的实现
    4. 工厂方法模式的应用
    5. 工厂方法模式的优/缺点
    6. 工厂方法模式的适用环境
    7. 配量文件与反射
    8. 工厂方法的重载
    9. 工厂方法的隐藏

    工厂方法模式概述

    考虑这样一个系统,使用简单工厂模式设计的按钮工厂类可以返回一个具体类型的 按钮实例,例如圆形按钮矩形按钮、菱形按钮等。
    在这里插入图片描述
    在这个系统中如果需要增加一种新类型的按钮,例如椭圆形按钮,那么除了增加一个新的具体产品类之外还需要修改工厂类的代码,这就使得整个设计在一定程度上违反了开闭原则。
    现在对该系统进行修改,不再提供一个按钮工厂类来统一负责所有产品的创建,而是将具体按钮的创建过程交给专门的工厂子类去完成。先定义一个抽象的按钮工厂类,再定义具体的工厂类来生产圆形按钮、矩形按钮、菱形按钮等,它们实现了在抽象按钮工厂类中声明的方法。这种抽象化的结果是使得这种结构可以在不修改具体工厂类的情况下引进新的产品,如果出现新的按钮类型,只需要为这种新类型的按钮定义一个具体的工厂类就可以创建该新按钮的实例,这种改进的设计方案即为工厂方法模式。工厂方法模式通过引入抽象的工厂类,使得它具有超越简单工厂模式的优越性,让系统更加符合开闭原则。
    在这里插入图片描述
    在工厂方法模式中不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构。
    工厂方法模式的定义如下:
    工厂方法模式:定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

    工厂方法模式简称为工厂模式( Factory Pattern),又可称作虚拟构造器模式('Virtual
    Constructor Pattern)或多态工厂模式( Polymorphic Factory Pattern)。工厂方法模式是种类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类负责生成具体的产品对象,这样做的目的是将产品类的实例操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类

    工厂方法模式结构与实现

    工厂方法模式结构

    工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法,而由其子类来具体实现
    工厂方法,创建具体的产品对象。
    在这里插入图片描述
    工厂方法模式包含以下4个角色。
    (1) Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型,也就是产品对象的公共父类
    (2) ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应
    (3) Factory(抽象工厂):在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。
    (4) ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例

    工厂方法模式实现

    与简单工厂模式相比,工厂方法模式最重要的特点是引入了抽象工厂角色,抽象工厂可以是接口,也可以是抽象类或者具体类。其典型代码如下:

    public interface Factory {
    	public Product factoryMethod();
    }
    

    在抽象工厂中声明了工厂方法但并未实现工厂方法,具体产品对象的创建由其子类负责,客户端针对抽象工厂编程,可在运行时再指定具体工厂类,具体工厂类实现了工厂方法,不同的具体工厂可以创建不同的具体产品。其典型代码如下:

    public class ConcreteFactory implements Factory {
    	public Product factoryMethod() {
    		return new ConcreteProduct();
    	}
    }
    

    在实际使用时,具体工厂类在实现工厂方法时除了创建具体产品对象之外,还可以负责产品对象的初始化工作以及一些资源和环境配置工作,例如连接数据库、创建文件等。在客户端代码中,开发人员只需关心工厂类即可,不同的具体工厂可以创建不同的产品。典型的客户端代码片段如下:

    Factory factory;
    //可通过配置文件与反射机制实现
    factory = new ConcreteFactory();
    Product product;
    product= factory.factoryMethod();
    

    可以通过配置文件来存储具体工厂类 ConcreteFactory的类名,再通过反射机制创建具体工厂对象,在更换新的具体工厂时无须修改源代码,系统扩展更为方便

    工厂方法模式应用实例

    下面通过一个应用实例来进一步学习和理解工厂方法模式。

    1. 实例说明

    某系统运行日志记录器( Logger)可以通过多种途径保存系统的运行日志,例如通过文件记录或数据库记录,用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时,开发人员发现需要对日志记录器进行一些初始化工作,初始化参数的设置过程较为复杂,而且某些参数的设置有严格的先后次序,否则可能会发生记录失败。 为了更好地封装记录器的初始化过程并保证多种记录器切换的灵活性,现使用工厂方法模式设计该系统(注:在Java中常用的日志记录工具有SLF4J、Log4、GCLog Viewer、Logstash等)。
    2.实力类图
    通过分析,本实例结构图如下
    在这里插入图片描述
    在图4-4中, Logger接口充当抽象产品,其子类 FileLogger和 DatabaseLogger充当具体产品, LoggerFactory接口充当抽象工厂,其子类 FileLoggerFactory和DatabaseLoggerFactory充当具体工厂。

    3.实例代码
    (1)Logger:日志记录器接口,充当抽象产品角色。

    //desagmpatterns.factorymethod Logger. Java
    package designpatterns. factorymethod;
    
    public interface Logger {
    	public void writeLog();
    }
    

    (2) DatabaseLogger:数据库日志记录器,充当具体产品角色

    //designpatterns.factorymethod. DatabaseLogger.java
    package designpatterns.factorymethod
    
    public class DatabaseLogger implements Logger {
    	public void writeLog() {
    		System.out.println("数据库日志记录");
    	}
    

    (3) Filelogger:文件日志记录器,充当具体产品角色。

    public class FileLogger implements Logger {
    	public void writeLog() {
    		System.out.printin("文件日志记录");
    	}
    }
    

    (4) LoggerFactory:日志记录器工厂接口,充当抽象工厂角色

    public interface LoggerFactory {
    	public Logger createLogger(); // 抽象工厂方法
    }
    

    (5) DatabaseFactory:数据库日志记录器工厂类,充当具体工厂色

    public class DatabaseLoggerFactory implements LoggerFactory {
    	public Logger createLogger(){
    		//连接数据库,代码省略
    		//创建数据库日志记录器对象
    		Logger logger= new DatabaseLogger();
    		//初始化数据库日志记录器,代码省略
    		return logger;
    	}
    }
    

    (6) FileLoggerFactory:文件日志记录器工厂类,充当具体工厂角色

    public class FileLoggerFactory implements LoggerFactory{
    	public Logger createlogger() {
    		// 创建文件日志记录器对象
    		Logger logger= new FileLogger();
    		//创建文件,代码省略
    		
    		return logger;
    	}
    } 
    

    (7) Client:客户端测试类

    public class Client {
    	public static vold main(string []args){
    		LoggerFactory factory;
    		Logger logger;
    		factory = new FileloggerFactory();//可引入配置文件和反射机制实现
    		logger = factory.createlogger();
    		logger.writeLog();
    	}
    }
    

    结果及分析
    编译并运行程序,输出结果如下

    文件日志记录
    

    如果需要更换日志记录器,只需要修改客户端代码中的具体工厂类的类名即可,例如将FileLoggerFactory改为 DatabaseLoggerFactory,此时输出结果如下:

    数据库日志记录
    

    如果需要增加并使用新的日志记录器,只需要对应增加一个新的具体工厂类,然后在客户端代码中修改具体工厂类的类名,原有类库的源代码无须做任何修改。通过引入配置文件并使用反射机制可以实现在不修改客户端代码的基础上更换具体工厂类,在下面将详细说明其实现过程,让系统更加符合开闭原则,具备更好的灵活性和可扩展性。

    反射机制与配置文件

    在上一节的日志记录器实例中,在更换日志记录器时需要修改客户端代码,对于客户端而言并不符合开闭原则,本节将介绍如何在不修改任何客户端代码的基础上更换或增加新的日志记录方式。
    在实际应用开发中可以对具体工厂类的实例化过程进行改进,在客户端代码中不直接使用new关键字来创建工厂对象,而是通过Java反射机制结合配置文件(例如XML文件)来生成具体工厂对象。在整个实现过程中需要用到两个技术,即Java反射机制与配置文件。
    1.Java反射机制
    Java反射( Java Reflection)是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制,包括类的方法、属性、父类等信息,还包括实例的创建和实例类型的判断等。在反射中使用最多的类是 Class, Class类的实例表示正在运行的Java应用程序中的类和接口,其 forName(String className)方法可以返回与带有给定字符串名的类或接口相关联的Class对象,再通过 Class对象的 newInstance()方法创建此对象所表示的类的一个新实例,即通过一个类名字符串得到类的实例。例如创建一个字符串类型的对象,其代码如下:

    //通过类名生成实例对象并将其返回
    Class c = Class.forName("java.lang.String");
    Object obj = c .newInstance();
    return obj;
    

    此外,在JDK中还提供了java.lang.reflect包,封装了其他与反射相关的类,在本书中只用到上述简单的反射代码,在此不予扩展。
    2.配置文件
    软件系统的配置文件通常为XML文件,可以使用DOM( Document Object Model)、SAX( Simple API for XMl.)、StAx( Streaming API for XML.)等技术来处理XML文件。在软件开发中可以把类名存储到XML配置文件中,再读取配置文件获取类名字符串,然后通过Java反射机制来创建对象。例如将上一小节的具体日志记录器工厂类类名FileLoggerFactory存储在如下XML格式的配置文件 c

    <!-- config.xml -->
    <?xml version ="1.0"?>
    <config>
    <className>designpatterns.factorymethod.FileLoggerFactory</className>
    </config>
    

    在该文件中, designpatterns.factorymethod为具体工厂类所在的包名, FileLoggerFactory 为具体工厂类的类名。
    为了读取该配置文件,并通过存储在其中的类名字符串反射生成对象,可以创建一个工具类XMLUtil,其详细代码如下

    package design.simplefactory;
    
    import java.io.IOException;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    
    public class XMLUtil {
    	public static Object getBean() {
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = null;
    		try {
    			builder = factory.newDocumentBuilder();
    			
    			Document document = builder.parse("src/design/config.xml");
    			
    			// 获取包含类名的文本节点
    			NodeList list = document.getElementsByTagName("className");
    			Node classNode = list.item(0).getFirstChild();
    			String cName = classNode.getNodeValue().trim();
    			Class c = Class.forName(cName);
    			Object obj = c.newInstance();
    			return obj;
    		} catch (ParserConfigurationException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SAXException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return null;
    	}
    
    }
    
    

    注:在后续的设计模式学习过程中将多次重用该类。
    有了 XMLUtiI类之后,可以对日志记录器的客户端代码进行修改,不再直接使用new关键字来创建具体的工厂类,而是将具体工厂类的类名存储在XML文件中,再通过XMLUtil类的静态工厂方法 getBean()进行对象的实例化,将代码修改如下:

    public class Client {
    	public static vold main(string []args){
    		LoggerFactory factory;
    		Logger logger;
    		// getBean()的返回值类型为Object,需要进行强制类型转换
    		factory = (LoggerFactory) XMLUtil.getBean();
    		logger = factory.createlogger();
    		logger.writeLog();
    	}
    }
    

    在引入 XMLUti类和XM配置文件之后,如果需要增加一种新类型的日志记录方式只需要执行以下4个步:
    (1)新的日志记录器需要继承抽象日志记录器 Logger
    (2)对应增加一个新的具体日志记录器工厂,继承抽象日志记录器工厂LoggerFacto
    ry,并实现其中的工厂方法 createLogger(),设置好初始化参数和环境变量,返回具体日志记录器对象。
    (3)修改配置文件 config.xml,用新增的具体日志记录器工厂类的类名字符替换原有工厂类的类名字符串
    (4)编译新增的具体日志记录器类和具体日志记录器工厂类,运行客户端测试类即可使用新的日志记录方式,而原有类库代码无须做任何修改,完全符合开闭原则

    通过上述重构可以使系统更加灵活,由于很多设计模式都关注系统的可扩展性和灵活性,因此都定义了抽象层,在抽象层中声明业务方法,而将具体业务方法的实现放在实现层中。为了更好地体现这些设计模式的特点,本书在很多设计模式中都使用XML配置文件和Java反射机制来创建对象。

    工厂方法的重载

    在某些情况下,可以通过多种方式来初始化同一个产品类。例如上面所提到的日志记录器类,可以为各种日志记录器提供默认实现;还可以为数据库日志记录器提供数据库连接字符串,为文件日志记录器提供文件路径;也可以将相关参数封装在一个 Object类型的对象中,通过 Object对象将配置参数传入工厂类。此时可以提供一组重载的工厂方法,以不同的方式对产品对象进行创建。当然,对于同一个具体工厂而言,无论使用哪个工厂方法,所创建的产品类型均要相同。重载的工厂方法结构图如图所示。
    在这里插入图片描述

    引入重载方法后,抽象工厂类LoggerFactory的代码修改如下:

    public interface LoggerFactory{
    	public Logger createLogger();
    	public Logger createLogger(String args);
    	public Logger createLogger(Object obj);
    }
    
    

    具体工厂类 DatabaseLoggerFactory的代码修改如下

    public class DatabaseLoggerFactory implements LoggerFactory{
    	public Logger createLogger(){
    			//使用默认方式连接数据库,代码省略
    			Logger logger = new DatabaseLogger();
    			//初始化数据库日志记录器,代码省略
    			return logger;
    	}
    	public Logger createLogger(String args){
    		//使用参数args作为连接字符串来连接数据库,代码省略
    		Logger logger = new DatabaseLogger();
    		//初始化数据库日志记录器,代码省略
    		return logger;
    	}
    	public Logger createLogger(Object obj){
    		//使用封装在参数objb中的连接字符串来连接数据库,代码省略
    		Logger logger = new DatabaseLogger();
    		//使用封装在参数obj中的数据来初始化数据库志记录器,代码省略
    		return logger;
    	}
    	
    }
    	//其他具体工厂类代码省略
    
    

    在抽象工厂中声明了多个重载的厂方法,在具体工厂中实现了这些工了方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求。

    工厂方法的隐藏

    有时候,为了进一步简化客户端的使用,还可以对客户端隐藏工厂方法,此时在工厂类中直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法。
    如果对客户端隐藏工厂方法,那么如图4-4所示的日志记录器结构图可修改为如图所示的结构图

    在这里插入图片描述
    在图4-6中,抽象工厂类 LoggerFactory的代码修改如下:

    //将接口改为抽象类
    public abstract class LoggerFactory{
    	//在工厂类中直接调用日志记录器类的业务方法 
    	public void writeLog(){
    		Logger logger = this.createLogger();
    		logger.writeLog();
    	}
    	public abstract logger createLogger();
    }
    

    客户端代码修改如下:

    public class Client{
    	public static void main(String [] args) {
    		LoggerFactory factory;
    		factory = (LoggerFactory) XMLUtil.getBean();
    		//直接使用工厂对象来调用产品对象的业务方法
    		factory.writeLog();
    	}
    }
    

    通过把业务方法的调用移至工厂类中,可以直接使用工厂对象来调用产品对象的业务方法,客户端无须使用工厂方法来创建产品对象。在某些情况下可以使用这种设计方案。

    工厂方法模式优/缺点与适用环境

    工厂方法模式是简单工厂模式的延伸,它继承了简单厂模式的优点,同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一,是很多开源框架和API类库的核心模式。
    工厂方法模式优点
    (1)在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无需知道具体产品类的类名。
    (2)基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,正是因为所有的具体工厂类都具有同一抽象父类。
    (3)使用工厂方法模式的另一个优点是在系统中加入新产品时无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,只需要添加一个具体工厂和具体产品即可,这样系统的可扩展性也就变得非常好,完全符合开闭原则。
    工厂方法模式缺点
    工厂方法模式的缺点主要如下:
    (1)在添加新产品时需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
    (2)由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度。
    工厂方法模式适用环境
    在以下情况下可以考虑使用工厂方法模式:
    (1)客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体产品对象由具体工厂类创建,可将具体工厂类的类名存储在配置文件或数据库中。
    (2)抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时子类对象将覆盖父类对象,从而使得系统更容易扩展。

    本章小结

    1. 在工厂方法模式中定义一个用于创建对象的接口,但是让子类决定将哪一个类实化。工厂方法模式让一个类的实例化延迟到其子类,它是一种类创建型模式。
    2. 工厂方法模式包含抽象产品、具体产品、抽象工厂和具体工厂4个角色。其中,抽产品是定义产品的接口;具体产品实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建;抽象工厂声明了工厂方法,用于返回一个产品;具体工厂是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,返回一个具体产品类的实例。
    3. 工厂方法模式的优点主要是提供了专门的工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节;它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部;在系统中加入新产品时完全符合开闭原则。其缺点主要是系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,会给系统带来一些额外的开销;增加了系统的抽象性和理解难度。
    4. 工厂方法模式适用于以下环境:客户端不知道它所需要的对象的类;抽象工厂类通过其子类来指定创建哪个对象。
    5. 通过引入配置文件和反射机制将具体工厂类的类名存储在配置文件中,然后使用反射来生成工厂对象,使得系统可以在不修改任何已有代码的基础上能够增加新的产品类,完全符合开闭原则。
    6. 在抽象工厂中可以声明多个重载的工厂方法,在具体工厂中实现了这些工厂方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求
    7. 在工厂类中可以直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法,实现对工厂方法的隐藏。
    展开全文
  • 女娲造人工厂方法模式.zip
  • 介绍的是工厂模式 包括简单工厂模式、工厂方法模式、抽象工厂模式 包括PPT和代码
  • 这个是用工厂方法模式写的一个简易的计算器,这个代码可重用性高,满足开闭原则。
  • 工厂方法模式(Factory Method) 抽象工厂模式 (Abstract Factory) 但是在实际过程中还有一种工厂模式经常被使用,那就是 简单工厂模式(Simple Factory)。有一种常见的分类的方法:根据产品是由具体产品还是...
  • 用java语言实现工厂方法模式和抽象工厂模式
  • 简单工厂模式和工厂方法模式的区别 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了于具体产品的依赖。而工厂方法模式定义了一个用于...
  • 工厂方法模式,往往是设计模式初学者入门的模式,的确,有人称之为最为典型最具启发效果的模式。 android中用到了太多的工厂类,其中有用工厂方法模式的,当然也有很多工厂并不是使用工厂方法模式的,只是工具管理类...
  • 工厂方法模式和抽象工厂模式的区别,对工厂方法模式和抽象工厂模式做了简单的比较
  • 快速理解工厂方法模式,及其在源码中的应用

    (一)、什么是工厂方法模式

    有一个总工厂负责生产各种电视产品,此时来了一个生产小米电视的需求,就会分配出一个制作小米电视的工厂,然后就能用该工厂生产小米电视了。
    上面这种通过工厂来实例化类的方式抽象到设计模式中就是工厂方法模式。

    (二)、工厂方法模式中的角色

    工厂方法模式中有四种角色,理解这四种角色就能理解工厂方法模式。

    抽象工厂(Factory):也就是开题这个例子中的总工厂,抽象工厂是所有具体工厂的基类,在抽象工厂角色中,声明了生成产品实例的方法。抽象工厂的目的是为了让实例的生成不再通过new,而是通过生成实例的专用方法

    具体工厂(ConcreteFactory):也就是开题这个例子中的制作小米电视的工厂,是抽象工厂的子类,实现抽象工厂中定义的生成产品实例的方法。

    抽象产品(Product):也就是开题这个例子中的电视产品,是一个总的抽象产品,定义了一个产品的一系列方法。

    具体产品(ConcreteProduct):也就是开题这个例子中的小米电视,是一个具体的产品,实现抽象产品的方法。

    (三)、工厂方法模式代码案例

    下面的代码描述的是工厂方法模式的案例,实现本文第一章的场景
    抽象电视工厂类,提供一个produceTv的抽象方法。

    public abstract class TvFactory {
        public abstract Television produceTv();
    }
    

    抽象电视产品类,提供一个show方法。

    public abstract class Television {
        public abstract void show();
    }
    

    具体的电视产品小米电视:

    public class XiaomiTelevision extends Television{
        @Override
        public void show() {
            System.out.println("用小米电视看视频");
        }
    }
    

    具体工厂:用于生产小米电视:

    public class XiaomiTvFactory extends TvFactory{
        @Override
        public Television produceTv() {
            System.out.println("制造了小米电视");
            return new XiaomiTelevision();
        }
    }
    

    最后写个测试方法:

    public class Main {
        public static void main(String[] args) {
            Television XiaomiTelevision = new XiaomiTvFactory().produceTv();
            XiaomiTelevision.show();
        }
    }
    
    

    这个时候又来了一个华为电视的需求,只需要和生产小米电视一样,生成华为电视具体工厂和华为电视具体类就可以了,如下:

    public class HuaweiTvFactory extends TvFactory{
        @Override
        public Television produceTv() {
            System.out.println("制造了一台华为电视");
            return new HuaweiTelevision();
        }
    }
    
    public class HuaweiTelevision extends Television{
        @Override
        public void show() {
            System.out.println("使用华为电视看视频");
        }
    }
    

    然后就可以使用了

    public class Main {
        public static void main(String[] args) {
            Television XiaomiTelevision = new XiaomiTvFactory().produceTv();
            XiaomiTelevision.show();
            Television HuaweiTelevision = new HuaweiTvFactory().produceTv();
            HuaweiTelevision.show();
        }
    }
    

    (四)、为什么要用工厂方法模式

    从上面的例子也能看出来,使用工厂方法模式后代码变得更加复杂了,并且想在项目中应用上貌似很困难。但是工厂方法模式却能带来一些不一样的东西

    1、良好的扩展性

    在设计一个项目的时候,首先要设计的是整体的代码架构。设计了顶层的抽象工厂和抽象产品之后,后续有其他的底层实现时,也只需要新增一个继承了抽象工厂的具体工厂类就行。

    2、良好的封装性

    以前创建一个类需要通过new方法创建,有了工厂类之后,创建的这个动作就交给工厂类去实现类。假设创建一个类的过程很复杂,有许多额外的逻辑,那么这些逻辑只需要在工厂类中实现一次,具体的产品都可以通过工厂类直接获取到。减少模块间的耦合。

    3、框架和实现的隔离性

    我们可以把抽象工厂和抽象产品定义为框架,而具体工厂和具体产品是实现。通过工厂方法模式,框架和实现之间是分离的。实现了底层的修改不会导致上层的改动。

    (五)、工厂方法模式在源码中的应用

    我们来看一下slf4j中是如何应用工厂方法模式的:

    首先slf4j定义一个抽象工厂ILoggerFactory

    public interface ILoggerFactory {
        Logger getLogger(String var1);
    }
    

    接着定义了一个抽象产品Logger:

    public interface Logger {
        ... ...
    }
    

    具体工厂有很多,都实现了抽象工厂,这里展示其中一个SubstituteLoggerFactory

    具体工厂用于生产具体的产品,SubstituteLogger就是一种具体的产品,从上边的代码中就可以看到,SubstituteLoggerFactory工厂在生产SubstituteLogger具体产品时,做了一定的处理。而真正使用时,只需要通过getLogger方法就可以得到具体产品,这就是工厂方法模式的魅力。

    (六)总结

    工厂方法模式相比于适配器模式、迭代器模式或者模板方法模式更加难理解,也更加难应用到项目中。但是我们依旧可以从中学到设计的魅力,学到接口、抽象类存在的目的。

    展开全文
  • 关于简单工厂模式,工厂方法模式,抽象工厂模式的一次总结 模式 定义 简单工厂模式 定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类。 工厂方法模式 定义一个...

    LOG:更新日志

    • 2019-3-29 第一次完成此文章V1.0.0版本
    • 2019-4-10 更新标题,增加了“java版”字样,文章版本更新至V1.0.1

    一、简单工厂模式,工厂方法模式,抽象工厂模式定义

    模式定义
    简单工厂模式定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类
    工厂方法模式定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类
    抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类

    PS:简单工厂模式不是GOF 23种设计模式之一!它只是日常编程中一种常用的方法或者说是这是一种习惯。

    PS:文中部分看不懂的名词文末都有解释。

    二、三种工厂模式的优缺点以及适用场景

    简单工厂模式优缺点以及适用场景

    • 优点

      1. 实现了对象创建和使用的分离(即业务逻辑和界面逻辑分离)。
      2. 客户端无需知道所创建的具体产品类的类名,只需知道具体产品类所对应的参数即可。
      3. 通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。
    • 缺点

      1. 工厂类集中了所有产品的逻辑,职责过重,一旦不能工作,整个系统都要受到影响。
      2. 增加系统中类的个数,增加了系统的复杂度和理解难度。
      3. 系统扩展困难,一旦添加新产品不得不修改工厂逻辑。
      4. 由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构,工厂类不能得到很好地扩展。
    • 适用环境

      1. 工厂类负责创建的对象比较少,由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。
      2. 客户端只知道传入工厂类的参数,对于如何创建对象并不关心。

    工厂方法模式优缺点以及适用场景

    • 优点

      1. 符合开放-关闭原则(简称开-闭原则)
      2. 将创建对象的逻辑与任务交给了工厂类
    • 缺点

      1. 每次新增产品,产品类都需要创建对应工厂类,增加了系统的开销
    • 适用场景

      1. 创建某些类的对象的逻辑比较复杂, 并且有很多分支条件,而且还可能增加新的条件。
      2. 一个类不知道它所需要的对象的类 。
      3. 一个类通过其子类来指定创建哪个对象。
      4. 需要封装创建类的对象的逻辑, 使得这些逻辑局部化。

    抽象工厂模式优缺点以及适用场景

    • 优点

      1. 隔离了具体类的生成, 使得客户端并不需要知道什么被创建。

      2. 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

      3. 增加新的产品族很方便,无须修改已有系统,符合开闭原则

        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!
        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!
        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!

    • 缺点

      1. 增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这显然会带来较大的不便,违背了开闭原则
    • 适用场景

      1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节。
      2. 系统中有多于一个的产品族,但每次只使用其中某一产品族。
      3. 属于同一个产品族的产品将在一起使用, 这一约束必须在系统的设计中体现出来。
      4. 产品等级结构稳定, 设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

    三、名词解释

    1. 开放-关闭原则(开闭原则): 用抽象构建架构,用实现扩展细节。
      PS:讲人话就是不修改源代码。

    2. 产品等级结构: 产品等级结构即产品的继承结构

    3. 产品族: 产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品

    下面用一张图描述到底什么是产品族,什么是产品等级结构。这种图叫做相图
    横着的表示不同种类的产品,竖着的表示同一种类产品的不同类型。
    例子:
    一行表示一部手机的组成:CPU(处理器)、RAM(运行内存)、ROM(机身存储)
    一列比如可以表示如下
    CPU有:骁龙855、骁龙845、骁龙835
    RAM有:4G、8G、16G
    ROM有:64G、128G、256G
    在这里插入图片描述
    简单工厂模式,工厂方法模式以及抽象工厂模式的相图(博主自己理解画的)
    在这里插入图片描述

    四、简单工厂模式、工厂方法模式与抽象工厂模式之间的区别

    • 简单工厂模式与工厂方法模式区别:
    1. 简单工厂模式不符合开闭原则,工厂方法模式符合开闭原则。
    2. 两个模式中心不同。简单工厂模式的中心是一个实体工厂类,工厂方法模式的中心是抽象工厂类或接口。
    3. 简单工厂模式中,工厂类包含创建对象的逻辑判断(如:if…else或switch…case);工厂方法 模式中,不必包含创建对象的逻辑判断。
    • 工厂方法模式与抽象工厂模式区别:
    1. 工厂方法模式中一个实体工厂类只能创建一种实体产品类;抽象工厂模式中一个实体工厂类可以创建多种实体产品类。

      PS:讲人话就是,工厂方法模式:一个工厂一种产品抽象工厂模式:一个工厂多种产品

    2. 工厂方法模式只有一个抽象产品类,抽象工厂模式有多个抽象产品类。

    五、抽象工厂模式的两种情况:①符合开闭原则;②不符合开闭原则

    又称抽象工厂模式“开闭原则”的倾斜性

    • ①符合开闭原则情况

      增加产品族对于增加新的产品族抽象工厂模式很好地支持开闭原则,只需要增加具体产品并对应增加一个新的具体工厂,对已有代码无须做任何修改。

    • ②不符合开闭原则情况

      增加新的产品等级结构对于增加新的产品等级结构 ,需要修改所有的工厂角色,包括抽象工厂类,在所有的工厂类中都需要增加生产新产品的方法,违背了开闭原则。

    六、三种模式例子java实现代码

    java实现简单工厂模式

    java实现工厂模式与抽象工厂模式

    七、个人简单总结

    综上所述:

    简单工厂模式:只有一个实体工厂类;一个实体工厂类生产所有的产品类,工厂根据传入的参数判断具体生产哪个产品给客户。

    工厂方法模式:只有一个抽象产品类;一个实体工厂类生产一种产品类,客户需要知道生产该产品的工厂类名称。

    抽象工厂模式:有多个抽象产品类;一个实体工厂类可以生产多种产品类,客户可以从一个工厂获得所有想要的产品。

    持续更新中…

    未经允许请勿转载,有问题请在评论区评论或者私信!

    展开全文
  • 抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml...

    简单工厂模式&工厂方法模式&抽象工厂模式的区别及优缺点及使用场景


    工厂模式是设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml中,jdbc连接数据库等)利用好工厂模式对程序的设计很有用处。

    工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式三类。也有把工厂方法模式划分到抽象工厂模式的,认为工厂方法是抽象工厂模式的特例的一种,就是只有一个要实现的产品接口。
    在这里插入图片描述

    简单工厂

    普通简单工厂

    就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图

    举个获取鼠标信息例子,我们有个例子。

    1. 创建获取鼠标信息共同接口
       public class LenoveMouse : IMouse
        {
            public string GetMouseInfo()
            {
                return "联想品牌鼠标";
            }
        }
    
    1. 联想鼠标实现类
     public string GetMouseInfo()
            {
                return "联想品牌鼠标";
            }
    

    3.惠普鼠标实现类

     public class HPMouse : IMouse
       {
           public string GetMouseInfo()
           {
               return "惠普品牌鼠标";
           }
       }
    
    1. 鼠标工厂类
      public class MouseFactory
        {
            /// <param name="type">0 代码惠普鼠标 1 代码联想鼠标</param>
            /// <returns></returns>
            public IMouse GetMouse(int type)
            {
                if (type == 0)
                {
                    return new HPMouse();
                }
                else if (type == 1)
                {
                    return new LenoveMouse();
                }
                else {
    
                    Console.WriteLine("请输入正确类型!");
                    return null;
                }
            }
        }
    
    1. 控制台调用
     class Program
        {
            static void Main(string[] args)
            {
                MouseFactory mouseFactory = new MouseFactory();
               string mouseInfo1 = mouseFactory.GetMouse(0).GetMouseInfo();
                Console.WriteLine(mouseInfo1);
               // 输出:惠普品牌鼠标
                string mouseInfo2 = mouseFactory.GetMouse(1).GetMouseInfo();
                Console.WriteLine(mouseInfo2);
               //输出:联想品牌鼠标
            }
        }
    

    多方法简单工厂

    是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的类型出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。关系图:
    在这里插入图片描述
    工厂类修改

     public class MouseFactory
        {
    
            public IMouse GetHPMouse()
            {
                return new HPMouse();
            }
    
            public IMouse GetMouse()
            {
                return new LenoveMouse();
            }
    
        }
    

    控制台调用修改

       class Program
        {
            static void Main(string[] args)
            {
                MouseFactory mouseFactory = new MouseFactory();
                string mouseInfo1 = mouseFactory.GetHPMouse().GetMouseInfo();
                //输出惠普鼠标品牌
                Console.WriteLine(mouseInfo1);          
                string mouseInfo2 = mouseFactory.GetLenoveMouse().GetMouseInfo();
                //输出联想鼠标品牌
                Console.WriteLine(mouseInfo2);
                Console.ReadLine();
            }
        }
    

    静态方法简单工厂

    将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

     public class MouseFactory
        {
    
            public static IMouse GetHPMouse()
            {
                return new HPMouse();
            }
    
            public static IMouse GetLenoveMouse()
            {
                return new LenoveMouse();
            }
    
        }
    

    控制台调用

      class Program
        {
            static void Main(string[] args)
            {          
                string mouseInfo1 = MouseFactory.GetHPMouse().GetMouseInfo();
                //输出惠普鼠标品牌
                Console.WriteLine(mouseInfo1);          
                string mouseInfo2 = MouseFactory.GetLenoveMouse().GetMouseInfo();
                //输出联想鼠标品牌
                Console.WriteLine(mouseInfo2);
                Console.ReadLine();
            }
        }
    

    工厂方法模式

    简单工厂模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改。假如增加其他品牌鼠标,工厂类需要修改,如何解决?就用到工厂方法模式,创建一个工厂接口和创建多个工厂实现类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。
    在这里插入图片描述
    增加Factory接口

      public interface Factory
        {
            /// <summary>
            /// 获取鼠标工厂
            /// </summary>
            /// <returns></returns>
             IMouse GetMouseFactory();
    
        }
    

    添加惠普鼠标工厂实现类

     public class HPMouseFactory:Factory
        {
            public IMouse GetMouseFactory()
            {
                return new HPMouse();
            }
        }
    
    

    添加联想鼠标工厂实现类

    
        public class LenoveMouseFactory : Factory
        {
            public IMouse GetMouseFactory()
            {
                return new LenoveMouse();
            }
        }
    

    控制台调用

    在这里插入代码片
    
    class Program
    {
        static void Main(string[] args)
        {
            //实例化惠普鼠标工厂
            Factory factory = new HPMouseFactory();
            string mouseInfo1 = factory.GetMouseFactory().GetMouseInfo();
            //输出惠普鼠标品牌
            Console.WriteLine(mouseInfo1);
            //实例化联想鼠标工厂
            Factory factory2 = new LenoveMouseFactory();
            string mouseInfo2 = factory2.GetMouseFactory().GetMouseInfo();
            //输出联想鼠标品牌
            Console.WriteLine(mouseInfo2);
            Console.ReadLine();
        }
    }
    工厂方法模式中我们把生成产品类的时间延迟,就是通过对应的工厂类来生成对应的产品类,在这里我们就可以实现“开发-封闭”原则,无论加多少产品类,我们都不用修改原来类中的代码,而是通过增加工厂类来实现。但是这还是有缺点的,如果添加键盘产品,就需要添加键盘工厂类。假如我们要实现的产品接口不止一个,也就是有多个产品接口,不同产品接口有对应的产品族。什么是产品族呢?简单的理解就是,不同厂家的不仅有鼠标,还有键盘,音响,笔记本可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。
    

    抽象工厂模式

    最后我们新增一个键盘产品类说明抽象工厂模式
    在这里插入图片描述

    1. 创建获取鼠标信息共同接口
       public class LenoveMouse : IMouse
        {
            public string GetMouseInfo()
            {
                return "联想品牌鼠标";
            }
        }
    
    1. 联想鼠标实现类
     public string GetMouseInfo()
            {
                return "联想品牌鼠标";
            }
    

    3.惠普鼠标实现类

      public class HPMouse : IMouse
        {
            public string GetMouseInfo()
            {
                return "惠普品牌鼠标";
            }
        }
        
    

    4.创建键盘接口类

     public interface IKeyboard
        {
             string GetKeyboardInfo();    
        }
    

    5.创建惠普键盘实现类

      public class HPKeyboard : IKeyboard
        {
            public string GetKeyboardInfo()
            {
                return "惠普键盘";
            }
        }
    

    6.创建联想键盘实现类

    
        public class LenoveKeyboard : IKeyboard
        {
            public string GetKeyboardInfo()
            {
                return "联想键盘";
            }
        }
    

    7.创建工厂接口类提供获取鼠标鼠标和键盘接口

     public interface Factory
        {
            /// <summary>
            /// 获取鼠标工厂
            /// </summary>
            /// <returns></returns>
             IMouse GetMouseFactory();
            /// <summary>
            /// 获取键盘工厂
            /// </summary>
            /// <returns></returns>
            IKeyboard GetKeyboardFactory();
    
        }
    

    8.创建联想工厂实现类

      public class LenoveFactory : Factory
        {
            public IKeyboard GetKeyboardFactory()
            {
                return new LenoveKeyboard();
            }
    
            public IMouse GetMouseFactory()
            {
                return new LenoveMouse();
            }
        }
    

    9.创建惠普工厂实现类型

      public class HPFactory:Factory
        {
            public IKeyboard GetKeyboardFactory()
            {
                return new HPKeyboard();
            }
    
            public IMouse GetMouseFactory()
            {
                return new HPMouse();
            }
        }
    

    控制台调用

       class Program
        {
            static void Main(string[] args)
            {
                //实例化惠普鼠标工厂
                Factory factory = new HPFactory();
                string mouseInfo1 = factory.GetMouseFactory().GetMouseInfo();
                string keyboard1 = factory.GetKeyboardFactory().GetKeyboardInfo();
    
                //输出惠普鼠标品牌
                Console.WriteLine(mouseInfo1);
                //输出惠普键盘
                Console.WriteLine(keyboard1);
                //实例化联想鼠标工厂
                Factory factory2 = new LenoveFactory();
                string mouseInfo2 = factory2.GetMouseFactory().GetMouseInfo();
                //输出联想鼠标品牌
                Console.WriteLine(mouseInfo2);
                //输出联想键盘品牌
                string keyboard2= factory2.GetKeyboardFactory().GetKeyboardInfo();
                Console.ReadLine();
            }
        }
    

    抽象工厂模式中我们可以定义实现不止一个接口,一个工厂也可以生成不止一个产品类,抽象工厂模式较好的实现了“开放-封闭”原则,是三个模式中较为抽象,并具一般性的模式。我们在使用中要注意使用抽象工厂模式的条件。
    无论是工厂模式增加代码复制度,有没有一种办法,不需要创建工厂,也能解决代码以后变动修改少方法。答案是有的,通过(ioc)控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体,将其所依赖的对象的引用传递给它。也可以说,(di)依赖被注入到对象中。
    后续继续讲解如何使ioc优化程序。
    案例代码下载
    由于水平有限,文章中难免有错误的地方,欢迎指出错误或不足之处,共同进步。欢迎转载,转载时请注明出处,谢谢。 ——by EricDrSun

    展开全文
  • 工厂方法模式 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。 工厂方法模式又简称为工厂模式(Factory Pattern),...
  • 工厂方法模式 工厂模式的本质 实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - oop七大原则 开闭原则:一个软件的实体应当对扩展开放,对修改关闭 ...
  • 1、简单工厂模式中包含判断什么对象的逻辑,而工厂方法模式则需要调用者判断要实例化什么具体类型的工厂进而创建出想要的对象。当增加新类时,简单工厂模式需要修改工厂类,而工厂方法模式不需要,因此工厂方法模式...
  • 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单...
  • 工厂方法模式的核心是抽象工厂类Factory,各种具体工厂类继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂...
  • Spring中的设计模式:工厂方法模式

    千次阅读 2020-04-06 13:29:13
    工厂方法模式是所有设计模式中比较常用的一种模式,但是真正能搞懂用好的少之又少,Spring底层大量的使用该设计模式来进行封装,以致开发者阅读源代码的时候晕头转向。 文章首发于微信公众号:Spring中的设计...
  • 工厂方法模式、简单工厂模式、抽象工程模式

    千次阅读 多人点赞 2018-04-07 22:11:06
    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 针对的问题:在面向对象编程中,最...
  • Java设计模式—工厂方法模式&抽象工厂模式

    万次阅读 多人点赞 2016-09-11 15:07:17
    工厂方法模式: 通用类图如下: 抽象产品类: 具体产品类 抽象工厂类 具体的工厂类 场景类: 工厂方法模式的优点: 使用场景: 工厂方法模式的扩展: (1)简单工厂模式 (2)多工厂模式 抽象工厂模式.....
  • 文章目录简单工厂(非模式,像编程习惯)工厂方法模式抽象工厂模式 除了使用new操作符之外,还有更多制造对象的方法。你将了解到实例化这个活动不应该总是公开的进行,也会认识到初始化经常造成“耦合”问题。 简单...
  • 掌握简单工厂模式、工厂方法模式、抽象工厂模式,并进行设计应用。 二、实验内容 (1)、 简单工厂模式使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,如果传入参数W,则返回一...
  • 工厂方法模式 文章目录工厂方法模式一、模式定义二、模式结构三、计算器问题类图四、优缺点优点缺点 一、模式定义 工厂方法模式(Factory Method Pattern又称为工厂模式,也叫作虚拟构造器(Virtual Constructor...
  • C++ 工厂方法模式

    万次阅读 2017-04-24 19:29:39
    工厂方法模式(Factory Method Pattern)是一种常用的对象创建型设计模式,此模式的核心思想是封装类中不变的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用以及方便后期维护拓展的目的。...
  • 工厂方法模式应用场景

    千次阅读 2018-01-30 11:29:25
    工厂方法模式  工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须...
  • 工厂方法模式和抽象工厂模式

    万次阅读 2018-09-10 16:16:02
    工厂方法模式 定义一个用于创建对象的接口,让子类决定实例化哪一个类。 在工厂里面可以对对象的创建做严格的定义,client端直接通过工厂创建出来就可以使用了。 public abstract class Product { //产品抽象类 ...
  •  工厂方法模式(Pattern:Factory Method)属于创建型模式,其意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,将核心类成为一个抽象工厂角色,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,280
精华内容 119,712
关键字:

工厂方法模式