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

    2009-04-28 11:50:29
    java工厂方法模式 java工厂方法模式java工厂方法模式java工厂方法模式java工厂方法模式java工厂方法模式
  • JAVA工厂方法模式

    千次阅读 2018-08-27 00:03:35
    工厂方法模式 通过本文将学习到 1、工厂方法模式的概念 2、工厂方法模式的UML图 3、工厂方法模式的实现 4、工厂方法模式的优缺点 5、工厂方法模式场景 6、总结 1、工厂方法模式的概念  工厂方法模式,简单...

     

    工厂方法模式

    通过本文将学习到

    1、工厂方法模式的概念

    2、工厂方法模式的UML图

    3、工厂方法模式的实现

    4、工厂方法模式的优缺点

    5、工厂方法模式场景

    6、总结


    1、工厂方法模式的概念

            工厂方法模式,简单来说是来为了解决简单工厂模式所出现的一些缺点而进行的改进。比如当一个简单的工厂模式要生产一个飞机。能够生产直升机,战斗机,波音747.但是如果要新增一个水上飞机。那么就要修改源代码,也就是修改工厂的源代码!添加一个业务逻辑,显然不符合开闭原则,所以就有了工厂方法模式。提供一个抽象工厂方法模式,这样就可以避免新增的时候修改源代码,只要新建一个类来继承了工厂方法模式即可。

    工厂方法模式:定义一个用于创建对象的接口,但是让子类来决定到底创建哪一个实例。工厂方法模式让一个类的实例化延迟到其子类。

    2、工厂方法模式的UML图

           

    Product:它是定义产品的接口,是工厂方法模式所创建的产品的父类。

    ConcreteProduct:具体产品.

    Factory:抽象工厂类中声明了工厂方法。

    ConcreteFactory:具体的工厂方法,继承了抽象工厂类,用来生产具体的对象。


    3、工厂方法模式的实现

    简单的实现、抽象工厂:

    public interface Factory{
         public Product factoryMethod();
    }

    具体的某一个工厂类:

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

    来一个实际的例子:日志系统。

    首先是产品类,充当抽象产品角色。

    package factoryMethodPattern;
    
    public interface Logger {
    	public void writeLog();
    
    }
    

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

    package factoryMethodPattern;
    
    public class DatabaseLogger implements Logger {
    
    	@Override
    	public void writeLog() {
    		// TODO Auto-generated method stub
    			System.out.println("数据库日志记录");
    	}
    
    }
    

    FileLogger:文件日志记录器,充当具体产品角色。

    package factoryMethodPattern;
    
    public class FileLogger implements Logger {
    
    	@Override
    	public void writeLog() {
    		System.out.println("文件日志记录。");
    
    	}
    
    }
    

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

    package factoryMethodPattern;
    
    public interface LoggerFactory {
    	public Logger createLogger();
    
    }
    

           c

    package factoryMethodPattern;
    
    public class DatabaseLoggerFactory implements LoggerFactory {
    
    	@Override
    	public Logger createLogger() {
    		// TODO Auto-generated method stub
    		Logger logger = new DatabaseLogger();
    		
    		return logger;
    	}
    
    }
    

     

     

    FileLoggerFactory:文件日志工厂

    package factoryMethodPattern;
    
    public class FileLoggerFactory implements LoggerFactory {
    
    	@Override
    	public Logger createLogger() {
    		// TODO Auto-generated method stub
    		Logger logger = new FileLogger();
    		
    		return logger;
    	}
    
    }
    

     

    Client测试类

    package factoryMethodPattern;
    
    public class Client {
    	public static void main(String[] args) {
    		LoggerFactory factory;
    		Logger logger;
    		factory = new FileLoggerFactory();
    		LoggerFactory factory2 = new DatabaseLoggerFactory();
    		logger = factory.createLogger();
    		logger.writeLog();
    		Logger logger2;
    		logger2 = factory2.createLogger();
    		logger2.writeLog();
    	}
    }
    

     


    4、工厂方法模式的优缺点

    工厂方法模式,是简单工厂模式的升级。完成了一些简单工厂模式不能完成的事情。

    优点:

    1. 在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户端隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需要产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。
    2. 基于工厂角色和产品角色的多态性设计是工厂方法的关键,他能够让工厂模式自主的创建产品对象,而如何创建这个对象的细节完全封装在工厂类。
    3. 使用工厂方法模式最大的优点就是你新加类的时候不用动源代码,只要写新的产品新的工厂来继承对应的类就行了。

    缺点:

    1. 既是优点又是缺点,你要新加类型的时候,既要创建产品类,又要创建工厂类,增加了一大波类。在一定的程度上增加系统的复杂度。
    2. 由于考虑到系统的可在性,需要引入抽象层,在客户·端代码中均用抽象定义,更加难以理解!

     


    5、工厂方法模式场景

    1、客户端不知道它所需要的对象的类,在工厂方法模式中,客户端不需要具体产品类的类名,只需要知道所对应的工厂即可,具体产品对象由具体工厂类创建,可见具体产品类的类名在配置文件或者数据库中存在!

    2、抽象工厂类通过其子类来指定创建那个产品类,用父类来新建子类可以提高可扩展性。


    6、总结

               工厂方法模式是简单工厂方法模式的升级。主要由抽象工厂类、抽象产品类、具体工厂类、具体产品类。主要的用途就是用来创建对象!我们只需要提供类名,然后由具体的工厂类去帮我们创建对象就够了,贼好用!在不需要新加很多类型,并且创建对象非常麻烦得时候工厂方法模式是一个非常好的模式。

    展开全文
  • Java 工厂方法模式

    2019-07-09 18:11:31
    简单工厂模式 工厂方法模式

    简单工厂模式和工厂方法模式

    简单工厂模式

    特点

    • 工厂方法模式是创建型模式之一,简单工厂又叫静态工厂方法模式。
    • 工厂类根据用户传递的参数创建对应的产品对象,避免了直接实例化对象,降低了耦合。

    角色定义

    • 工厂类:负责统一管理创建具体的产品对象。
    • 抽象产品类:定义产品的业务方法。
    • 具体产品类:实现抽象产品类中的业务方法。

    代码实现

    抽象产品类

    public abstract class Computer {
        public abstract void start();
    }
    

    具体产品类

    public class LenovoComputer extends Computer {
        @Override
        public void start() {
            System.out.println("联想开机了");
        }
    }
    
    public class HpComputer extends Computer {
        @Override
        public void start() {
            System.out.println("惠普开机了");
        }
    }
    

    工厂类

    public class LenovoComputer extends Computer {
        @Override
        public void start() {
            System.out.println("联想开机了");
        }
    }
    

    使用

    public class Demo {
        public static void main(String[] args) {
            Computer computer = ComputerFactory.createComputer("hp");
            computer.start();
        }
    }
    
    惠普开机了
    

    工厂方法模式

    特点

    • 简单工厂模式通过接收的参数,创建其对应的产品对象,如果新增一类产品时需要在判断分支上添加代码,违反了开闭原则。
    • 工厂方法模式核心是反射,需要增加新产品时,只需创建新的产品类。

    角色定义

    • 抽象工厂类:定义创建产品的方法。
    • 具体工厂类:实现创建产品的方法。
    • 抽象产品类:定义产品的业务方法。
    • 具体产品类:实现产品的业务方法。

    代码实现

    抽象产品类

    public abstract class Computer {
        public abstract void start();
    }
    

    具体产品类

    public class LenovoComputer extends Computer {
        @Override
        public void start() {
            System.out.println("联想电脑启动了");
        }
    }
    
    public class HpComputer extends Computer {
        @Override
        public void start() {
            System.out.println("惠普电脑启动了");
        }
    }
    

    抽象工厂类

    public abstract class ComputerFactory {
        public abstract <T extends Computer> T createComputer(Class<T> clz);
    }
    

    具体工厂类

    public class FSKComputerFactory extends ComputerFactory {
        @Override
        public <T extends Computer> T createComputer(Class<T> clz) {
            Computer computer = null;
            String clzName = clz.getName();
            try {
                computer = (Computer) Class.forName(clzName).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) computer;
        }
    }
    

    使用

    public class Demo {
        public static void main(String[] args) {
            FSKComputerFactory factory = new FSKComputerFactory();
            LenovoComputer computer = factory.createComputer(LenovoComputer.class);
            computer.start();
            HpComputer hpComputer = factory.createComputer(HpComputer.class);
            hpComputer.start();
        }
    }
    
    联想电脑启动了
    惠普电脑启动了
    
    展开全文
  • Java工厂方法模式

    2014-12-07 10:54:07
    //工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类; //工厂方法使一个类的实例化延迟到其子类; //抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义; public abstract class ...
    工厂模式:
    //工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类;
    //工厂方法使一个类的实例化延迟到其子类;
    //抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义;
    public abstract class Product
    {
    	//产品类的公共方法
    	public void method(){
    		//业务逻辑处理
    	};
    	//抽象方法
    	public abstract void method2();
    
    }
    //具体的产品类可以有多个,都继承于抽象产品类
    public class ConcreteProduct1 extends Product 
    {
    	public void method2(){
    		//业务逻辑处理
    	} 
    }
    public class ConcreteProduct2 extends Product 
    {
    	public void method2(){
    		//业务逻辑处理
    	} 
    }
    //抽象工厂创建类 
    public abstract class Creator {
    /*创建一个产品对象,其输入参数可以自行设置,通常为String、Enum、Class等,当然也可以为空*/
    public abstract <T extends Product > T creatProduct (Class <T> c);
    }
    //具体如何生产一个产品的对象,是由具体的工厂类来实现的。
    public class ConcreteCreator extends Creator  
    {
    	public <T extends Product >T createProduct(Class<T> c){
    	Product product = null;
    	try
    	{
    		product = (Product)Class.forName(c.getName()).newInstance();
    	}
    	catch (Exception e)
    	{
    		//异常
    	}
    	return (T)product;
    	} 
    }
    
    public class Client
    {
    	public static void main (String[] args ){
    		Creator creator = new ConcreteCreator();
    		Product product = creator.createProduct(ConcreteProduct1.class);
    		//业务处理
    	}
    }
    

    工厂方法模式的一个应用,就是JDBC数据库链接,数据库的改动,只涉及驱动名称的改换

    简单工厂模式:

    //静态简单工厂模式,弱化了的工厂模式
    //
    //工厂创建类 
    public class Creator { 
    	//静态方法
    public static <T extends Product > T creatProduct (Class <T> c);
    }
    
    public class ConcreteCreator extends Creator  
    {
    	public static <T extends Product >T createProduct(Class<T> c){
    	Product product = null;
    	try
    	{
    		product = (Product)Class.forName(c.getName()).newInstance();
    	}
    	catch (Exception e)
    	{
    		//异常
    	}
    	return (T)product;
    	} 
    }
    public class Client
    {
    	public static void main (String[] args ){
    		 
    		Product product = ConcreteCreator.createProduct(ConcreteProduct1.class);
    		//业务处理
    	}
    }







    展开全文
  • java 工厂方法模式

    2012-08-26 12:20:50
    工厂方法模式又称为多态性工厂模式或虚拟构造子模式;与简单工厂模式不同,在工厂方法模式中,核心的工厂类不再负责所有具体产品实例的创建, 而仅仅是需要负责给出具体工厂子类必须实现的接口,让工厂子类去负责...
    工厂方法模式又称为多态性工厂模式虚拟构造子模式;与简单工厂模式不同,在工厂方法模式中,核心的工厂类不再负责所有具体产品实例的创建,
    而仅仅是需要负责给出具体工厂子类必须实现的接口,让工厂子类去负责具体产品实例的创建。

    工厂方法模式的一般性结构是:


    与 简单工厂模式 类似的,下面使用工厂方法模式来模拟一个简单的加减乘除的计算器


    工厂方法模式结构示意图:



    共同运算接口:Operation.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  运算接口
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public interface Operation {

        /**
         * <B>方法描述:</B>
         * <p style="margin-left:20px;color:#A52A2A;">
         * 计算两个操作数的运算值
         * 
    @param operand1 <span style="color: #008080;"> 操作数1 </span>
         * 
    @param operand2 <span style="color: #008080;"> 操作数2 </span>
         * 
    @return <span style="color: #008080;"> 返回两个操作数的运算值 </span>
         
    */

        public double operate(Number operand1, Number operand2);
        
    }



    加法实现类:OperationAdd.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  加法实现类
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class OperationAdd implements Operation {

        @Override
        public double operate(Number operand1, Number operand2) {
            
            return operand1.doubleValue() + operand2.doubleValue();
        }


    }



    减法实现类:OperationSubtract.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  减法实现类
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class OperationSubtract implements Operation {

        @Override
        public double operate(Number operand1, Number operand2) {
            
            return operand1.doubleValue() - operand2.doubleValue();
        }


    }



    乘法实现类:OperationMultiply.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  乘法实现类
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class OperationMultiply implements Operation {

        @Override
        public double operate(Number operand1, Number operand2) {
            
            return operand1.doubleValue() * operand2.doubleValue();
        }


    }



    除法实现类:OperationDivision.java
    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  除法实现类
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class OperationDivision implements Operation {

        @Override
        public double operate(Number operand1, Number operand2) {
            try {
                if(operand2.doubleValue() == 0.0){
                    throw new Exception("警告:被除数不能为0");
                }
    else{
                    return operand1.doubleValue() / operand2.doubleValue();
                }

            }
     catch (Exception e) {e.printStackTrace();}
            return 0;
        }


    }


    抽象工厂接口:OperationCreator.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  抽象工厂接口
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public interface OperationCreator {

        /**
         * <B>方法描述:</B>
         * <p style="margin-left:20px;color:#A52A2A;">
         * 获取运算实例对象
         * 
    @return <span style="color: #008080;"> 返回运算实例对象 </span>
         
    */

        public Operation getInstance();
    }



    加法创造器:CreatorAdd.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  加法
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class CreatorAdd implements OperationCreator {

        @Override
        public Operation getInstance() {
            
            return new OperationAdd();
        }


    }



    减法创造器:CreatorSubtract.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  减法
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class CreatorSubtract implements OperationCreator {

        @Override
        public Operation getInstance() {
            
            return new OperationSubtract();
        }


    }



    乘法创造器:CreatorMultiply.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  乘法
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class CreatorMultiply implements OperationCreator {

        @Override
        public Operation getInstance() {
            
            return new OperationMultiply();
        }


    }



    除法创造器:CreatorDivision.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  除法
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class CreatorDivision implements OperationCreator {

        @Override
        public Operation getInstance() {
            
            return new OperationDivision();
        }


    }



    客户端测试类:Client.java

    package pattern.factory.method;
    /**
     * -----------------------------------------
     * @描述  客户端测试类
     * @作者  fancy
     * @邮箱  fancydeepin@yeah.net
     * @日期  2012-7-30 <p>
     * -----------------------------------------
     
    */

    public class Client {

        private static Operation operation;
        private static OperationCreator operationCreator;
        
        public static void main(String[] args) {
            
            operationCreator = new CreatorMultiply();
            operation = operationCreator.getInstance();
            System.out.println(operation.operate(4, 2.5));
            operationCreator = new CreatorDivision();
            operation = operationCreator.getInstance();
            System.out.println(operation.operate(40, 2.5));
            System.out.println(operation.operate(40, 0));
            
        }


    }

    展开全文
  • java 工厂方法模式 在上一篇有关模板方法模式的文章中 ,我展示了如何利用lambda表达式和默认方法 。 在本文中,我将探讨工厂方法模式,并了解如何利用方法引用,这是Java 8中与lambda表达式一起添加的另一项功能。...
  • 转自:java 工厂方法模式简单实例 介绍 在简单工厂模式中,我们提到,工厂方法模式是简单工厂模式的一个延伸,它属于Gof23中设计模式的创建型设计模式。它解决的仍然是软件设计中与创建对象有关的问题。它可以更好...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,800
精华内容 3,920
关键字:

java工厂方法模式

java 订阅