精华内容
下载资源
问答
  • 模板方法设计模式
    千次阅读
    2022-04-25 20:25:19

    目录

    模板方法设计模式的概念及核心内容:

    模板方法设计模式的具体例子:

    总结


    模板方法设计模式的概念及核心内容:

    模板方法设计模式在实际开发中是一种使用非常广泛的设计模式,也是一种非常重要的思想。其核心内容为:通过定义一个模板类,在模板类中规定其整体的骨架并确定哪些方法是允许子类去重写,哪些不允许子类重写或者哪些必须子类重写,其目的是保证其核心算法不被破坏。定义完模板类后,写出具体的子类去继承模板类并按规定好的框架来完成子类的定义。

    注:在定义模板类中的方法时,需要慎用修饰词:final、abstract。final用来可以用来定义那些不想被子类重写的方法,abstract则可以用来定义那些需要子类去具体实现的方法。

    模板方法设计模式的具体例子:

    定义一个模板类如下:其实际意义为老师和同学一天里做某些事都有相同的顺序,但是每一件事情又不相同。

    public abstract class PeopleInSchool {
        public PeopleInSchool() {}
    //定义子类不可重写的day()方法
        public final void day(){
            getup();
            eatbreakfast();
            inschool();
            eatlunch();
            classover();
            sleep();
        }
    //定义子类必须重写的抽象方法
        public abstract void getup();
        public abstract void eatbreakfast();
        public abstract void inschool();
        public abstract void eatlunch();
        public abstract void classover();
        public abstract void sleep();
    }
    

    学生类:

    public class Student extends PeopleInSchool{
        @Override
        public void getup() {
            System.out.println("在早上7点30起床");
        }
    
        @Override
        public void eatbreakfast() {
            System.out.println("在家里吃早饭");
        }
    
        @Override
        public void inschool() {
            System.out.println("在学校学习");
        }
    
        @Override
        public void eatlunch() {
            System.out.println("在食堂吃午饭");
        }
    
        @Override
        public void classover() {
            System.out.println("放学回家做作业");
        }
    
        @Override
        public void sleep() {
            System.out.println("在晚上9点睡觉");
        }
    }

    老师类:

    public class Teacher extends PeopleInSchool{
        @Override
        public void getup() {
            System.out.println("在早上6点30起床");
        }
    
        @Override
        public void eatbreakfast() {
            System.out.println("在家里/食堂吃早饭");
        }
    
        @Override
        public void inschool() {
            System.out.println("在学校给同学们上课");
        }
    
        @Override
        public void eatlunch() {
            System.out.println("在食堂/家里吃午饭");
        }
    
        @Override
        public void classover() {
            System.out.println("放学回家批改作业");
        }
    
        @Override
        public void sleep() {
            System.out.println("在晚上12点睡觉");
        }
    }
    

    总结

     模板方法模式是一种重要的设计模式,也代表一种抽象编程的思想。需要在之后的开发中细细去品味。感谢阅读。

     

    更多相关内容
  • 模板方法设计模式1

    2022-08-08 20:33:04
    介绍模板方法(TemplateMethod)定义了一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某
  • 模板方法设计模式两种实现方案

    千次阅读 2021-01-20 15:36:32
    目录 1、模板方法设计模式 2、继承姿势 3、依赖姿势 1、模板方法设计模式 2、继承姿势 3、依赖姿势

    目录

    1、模板方法设计模式

    2、继承实现方案

    3、依赖实现方案

    3.1 spring-jdbc 中的 JdbcTemplate

    3.2  阿里分布式事务框架Seata中的ExecuteTemplate


    1、模板方法设计模式

    模板方法(Template Method)模式的定义如下:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。
    该模式的主要优点如下。

    1. 它封装了不变部分,扩展可变部分。它把认为是不变部分的算法封装到父类中实现,而把可变部分算法由子类继承实现,便于子类继续扩展。
    2. 它在父类中提取了公共的部分代码,便于代码复用。
    3. 部分方法是由子类实现的,因此子类可以通过扩展方式增加相应的功能,符合开闭原则。

    2、继承实现方案

    模板方法模式需要注意抽象类与具体子类之间的协作。它用到了虚函数的多态性技术以及“不用调用我,让我来调用你”的反向控制技术。现在来介绍它们的基本结构。

    模板方法模式包含以下主要角色。

    1)抽象类/抽象模板(Abstract Class)

    抽象模板类,负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。

    ① 模板方法:定义了算法的骨架,按某种顺序调用其包含的基本方法。
    ② 基本方法:是整个算法中的一个步骤,包含以下几种类型。

    • 抽象方法:在抽象类中声明,由具体子类实现。
    • 具体方法:在抽象类中已经实现,在具体子类中可以继承或重写它。
    • 钩子方法:在抽象类中已经实现,包括用于判断的逻辑方法和需要子类重写的空方法两种。

    2)具体子类/具体实现(Concrete Class)

    具体实现类,实现抽象类中所定义的抽象方法和钩子方法,它们是一个顶级逻辑的一个组成步骤。

    模板方法模式的结构图如图 1 所示。

    模板方法模式的结构图

    JDK中的InputStream是采用的继承实现方案的模板方法设计模式,代码如下:
     

    //这是一个模板方法    
    public int read(byte b[], int off, int len) throws IOException {
            if (b == null) {
                throw new NullPointerException();
            } else if (off < 0 || len < 0 || len > b.length - off) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
    
            int c = read();
            if (c == -1) {
                return -1;
            }
            b[off] = (byte)c;
    
            int i = 1;
            try {
                for (; i < len ; i++) {
                    c = read();//read()是一个抽象方法,由各子类进行实现
                    if (c == -1) {
                        break;
                    }
                    b[off + i] = (byte)c;
                }
            } catch (IOException ee) {
            }
            return i;
        }

    3、依赖实现方案

    3.1 spring-jdbc 中的 JdbcTemplate

    模板类一个具体的类,将个性化的实现作为方法的参数,这样就避免类之间的继承关系,通过依赖关系实现了模板方法设计模式,这里给一个spring-jdbc中的示例,JdbcTemplate中的代码片段,如下:

    	//这是一个模板方法
         
        @Override
    	@Nullable
    	public <T> T execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)
    // PreparedStatementCallback是一个回调函数,
    			throws DataAccessException {
    
    		Assert.notNull(psc, "PreparedStatementCreator must not be null");
    		Assert.notNull(action, "Callback object must not be null");
    		if (logger.isDebugEnabled()) {
    			String sql = getSql(psc);
    			logger.debug("Executing prepared SQL statement" + (sql != null ? " [" + sql + "]" : ""));
    		}
    
    		Connection con = DataSourceUtils.getConnection(obtainDataSource());
    		PreparedStatement ps = null;
    		try {
    			ps = psc.createPreparedStatement(con);
    			applyStatementSettings(ps);
    			T result = action.doInPreparedStatement(ps);
                //T result = action.doInPreparedStatement(ps);这个操作可以个性化实现,由
                // 会传入的参数action来决定真正的实现业务逻辑
    			handleWarnings(ps);
    			return result;
    		}
    		catch (SQLException ex) {
    			// Release Connection early, to avoid potential connection pool deadlock
    			// in the case when the exception translator hasn't been initialized yet.
    			if (psc instanceof ParameterDisposer) {
    				((ParameterDisposer) psc).cleanupParameters();
    			}
    			String sql = getSql(psc);
    			psc = null;
    			JdbcUtils.closeStatement(ps);
    			ps = null;
    			DataSourceUtils.releaseConnection(con, getDataSource());
    			con = null;
    			throw translateException("PreparedStatementCallback", sql, ex);
    		}
    		finally {
    			if (psc instanceof ParameterDisposer) {
    				((ParameterDisposer) psc).cleanupParameters();
    			}
    			JdbcUtils.closeStatement(ps);
    			DataSourceUtils.releaseConnection(con, getDataSource());
    		}
    	}

    3.2  阿里分布式事务框架Seata中的ExecuteTemplate

     //模板方法
    /**
         * Execute t.
         *
         * @param <T>               the type parameter
         * @param <S>               the type parameter
         * @param sqlRecognizer     the sql recognizer
         * @param statementProxy    the statement proxy
         * @param statementCallback the statement callback
         * @param args              the args
         * @return the t
         * @throws SQLException the sql exception
         */
        public static <T, S extends Statement> T execute(List<SQLRecognizer> sqlRecognizers,
                                                         StatementProxy<S> statementProxy,
                                                         StatementCallback<T, S> statementCallback,
                                                         Object... args) throws SQLException {
    
            if (!RootContext.inGlobalTransaction() && !RootContext.requireGlobalLock()) {
                // Just work as original statement
                // statementCallback是个性化实现
                return statementCallback.execute(statementProxy.getTargetStatement(), args);
            }
    
            if (sqlRecognizers == null) {
                sqlRecognizers = SQLVisitorFactory.get(
                        statementProxy.getTargetSQL(),
                        statementProxy.getConnectionProxy().getDbType());
            }
            Executor<T> executor;
            if (CollectionUtils.isEmpty(sqlRecognizers)) {
                executor = new PlainExecutor<>(statementProxy, statementCallback);
            } else {
                if (sqlRecognizers.size() == 1) {
                    SQLRecognizer sqlRecognizer = sqlRecognizers.get(0);
                    switch (sqlRecognizer.getSQLType()) {
                        case INSERT:
                            executor = new InsertExecutor<>(statementProxy, statementCallback, sqlRecognizer);
                            break;
                        case UPDATE:
                            executor = new UpdateExecutor<>(statementProxy, statementCallback, sqlRecognizer);
                            break;
                        case DELETE:
                            executor = new DeleteExecutor<>(statementProxy, statementCallback, sqlRecognizer);
                            break;
                        case SELECT_FOR_UPDATE:
                            executor = new SelectForUpdateExecutor<>(statementProxy, statementCallback, sqlRecognizer);
                            break;
                        default:
                            executor = new PlainExecutor<>(statementProxy, statementCallback);
                            break;
                    }
                } else {
                    executor = new MultiExecutor<>(statementProxy, statementCallback, sqlRecognizers);
                }
            }
            T rs;
            try {
                rs = executor.execute(args);
            } catch (Throwable ex) {
                if (!(ex instanceof SQLException)) {
                    // Turn other exception into SQLException
                    ex = new SQLException(ex);
                }
                throw (SQLException) ex;
            }
            return rs;
        }
    }

     

    展开全文
  • 【Java】模板方法设计模式详解

    千次阅读 2020-07-29 17:26:31
    需求:统计不同操作的耗时时间模板操作 首先看这样一段代码: class StringOperate { public Long stringOperate(){ Long currentTime = System.currentTimeMillis(); //当前系统的时间(毫秒) String str = ...

    一. 需求:统计不同操作的耗时时间模板操作

    首先看这样一段代码:

    class StringOperate
    {
    	public  Long stringOperate(){
    		Long currentTime = System.currentTimeMillis(); //当前系统的时间(毫秒)
    		String str = "";
    		for (int i=0 ; i<10000;i++ )
    		{
    			str +=i; 
    		}
    		Long endTime = System.currentTimeMillis();
    		return endTime - currentTime;
    	}
    }
    
    class IntOperate
    {
    	public  Long intOperate(){
    	
    		Long currentTime = System.currentTimeMillis(); //当前系统的时间(毫秒)
    		int num = 0;
    		for (int i=0 ; i<10000000;i++ )
    		{
    			num += i; 
    		}
    		Long endTime = System.currentTimeMillis();
    		return endTime - currentTime;
    	}
    }
    
    class TemplateMethodDemo 
    {
    	public static void main(String[] args) 
    	{
    		//统计String的10000次操作和int操作相加10000000次的时间差
    		System.out.println(new StringOperate().stringOperate());
    		System.out.println(new IntOperate().intOperate());
    	}
    }
    

    二.改进思路

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    三. 使用模板方法设计模式改进代码

    // 抽象的模板类
    abstract class TemplateMethod
    {
    	//模板方法:总体算法的骨架,总体不能修改
    	final public Long typeOperate(){
    		Long currentTime = System.currentTimeMillis(); //当前系统的时间(毫秒)
    		// 具体操作留给子类完成
    		this.doWork(); 
    		Long endTime = System.currentTimeMillis();
    		return endTime - currentTime;	
    	}
    
    	protected abstract void doWork();
    }
    
    class StringOperate extends TemplateMethod
    {
    
    	public void doWork(){
    		String str = "";
    		for (int i=0 ; i<10000;i++ )
    		{
    			str += i; 
    		}
    	}
    }
    
    class IntOperate extends TemplateMethod
    {
    	public  void doWork(){
    		int num = 0;
    		for (int i=0 ; i<10000000;i++ )
    		{
    			num += i; 
    		}
    	}
    }
    
    class TemplateMethodDemo 
    {
    	public static void main(String[] args) 
    	{
    		//统计String的10000次操作和int操作相加10000000次的时间差
    		System.out.println(new StringOperate().typeOperate());
    		System.out.println(new IntOperate().typeOperate());
    	}
    }
    

    四.模板方法设计模式

    在父类的一个方法中定义一个总体算法的骨架(模板方法),而将某一些一些步骤延迟到子类中,因为不同的子类实现细节不同。模板方法使得子类可以在不改变算法结构的情况下, 重新定义算法中的某些步骤。

    抽象父类负责定义操作中的业务骨架,而把某些具体的实现步骤延迟到子类中去实现。

    在JavaWeb中:HttpServlet类中,也遵循这一命名规则,如doGet(),doPost()等方法。

    抽象父类至少提供的方法:

    • 模板方法:一种通用的处理方式,即模板(总体算法的骨架);
    • 抽象方法:一种具体的业务功能实现,由子类完成;

    注意:

    抽象父类提供的模版方法只是定义了一个通用算法,其实现必须依赖子类的辅助。

    模版方法作为模版样式不准子类覆写:

    答:用final修饰,不让子类覆盖

    抽象方法的权限又如何设置:

    答:使用protected修饰

    展开全文
  • 模板方法设计模式(详解加案例)

    千次阅读 2020-11-11 08:47:40
    模板方法设计模式 抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。 解决的问题: 当功能内部一部分实现是确定的,...

    模板方法设计模式

    抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

    解决的问题:
    当功能内部一部分实现是确定的,一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。
    换句话说,在软件开发中实现一个算法时,整体步骤是固定、通用的,这些步骤已经在父类中写好了。但是某些部分易变易变部分可以抽象出来,供不同子类实现。这就是一种模板模式。

    例如:办理银行业务
    步骤是固定的 — 模板 — 抽象类
    1) 取号 — 不变 — 具体方法
    2) 办理具体的业务 — 可变 — 抽象方法 — 不同子类根据自己具体的业务去实现
    3) 反馈评分 — 不变 — 具体方法

    案例

    计算出指定程序的运行时间(从程序开始到结束的耗时)
    分析:拿到当前时间,程序运行,拿到程序运行后的时间,返回时间差。
    在这个过程中,拿到当前时间,拿到程序运行后的时间,返回时间差。这些步骤都是固定的,唯一易变的就是运行的程序。把运行的程序running();方法抽象化,那么子类在继承父类后,需要重写running();方法,那么需要运行的程序就确定了(需要运行什么程序只需要在抽象方法中定义就可以)。子类只需要重写被抽象的方法,就能达到目的。

    class Test1 
    {
    	public static void main(String[] args){
    	    /*
    		 java.lang.System类有个静态方法:
    
    		 static long | currentTimeMillis()
    		 将当前时间以毫秒值返回
    
    		 计算时间差:
    		 在A时间点通过System类currentTimeMillis()拿到A时间点的毫秒值;
    		 再在B时间点通过System类currentTimeMillis()拿到B时间点的毫秒值;
    		 最后B时间点的毫秒值减去A时间点的毫秒值就是时间差。
    		*/
    
    		RuntimeA ra = new RuntimeA();
    		ra.showRunTime();
    
    		System.out.println("------------------------");
    
    		RuntimeB rb = new RuntimeB();
    		rb.showRunTime();
    	}
    }
    
    //模板类 --- 抽象类
    abstract class RuntimeTemplate
    {  
       //功能方法 --- 固定的步骤
       public final void showRunTime(){
    	  //1)程序运行开始时间
          long start = System.currentTimeMillis();
    
    	  //2)运行的程序
    	  running();
    
    	  //3)程序运行结束时间
    	  long end = System.currentTimeMillis();
    
    	  //4)计算耗时
    	  System.out.println("程序耗时:"+(end-start)+"毫秒");
       }
       
       //该方法封装运行的程序 --- 可变的 ---- 抽象出来
       public abstract void running();
    }
    
    //子类
    class RuntimeA extends RuntimeTemplate
    {
    	//重写程序运行的方法
    	public void running(){
    	   int sum = 0;
    	   for(int i=1;i<=1000;i++){
    	     sum+=i;
    	   }
    	}
    }
    
    class RuntimeB extends RuntimeTemplate
    {
    	//重写程序的运行方法
    	public void running(){
    	  int count = 0;
    	  for(int i=1;i<=99999;i++){
    	    if(i%2==0){
    		  count++;
    		}
    	  }
    	}
    }
    
    
    展开全文
  • Java模板方法设计模式[定义].pdf
  • 都知道在js中如果定义两个相同名称的方法,前一个方法就会被后一个方法覆盖掉,使用此特点就可以实现模板方法,感兴趣的朋友可以了解下本文哈
  • Java设计模式模板方法模式

    千次阅读 2022-01-21 10:42:54
    模板方法模式的结构图: ​ 模板方法模式有如下角色: 1、AbstractClass:抽象类,定义了一套算法框架。 2、ConcreteClass:具体实现类。 二、模板方法模式的实现: 1、创建抽象类,定义算法框架: /** * 创建抽象...
  • 本文实例讲述了Python设计模式模板方法模式。分享给大家供大家参考,具体如下: 模板方法模式(Template Method Pattern):定义一个操作中的算法骨架,将一些步骤延迟至子类中.模板方法使得子类可以不改变一个算法的...
  • 设计模式模板方法模式(附应用举例实现)
  • 本文实例讲述了PHP设计模式模板方法模式。分享给大家供大家参考,具体如下: 定义一个操作中的算法的框架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 模板...
  • 设计模式--模板方法模式java例子
  • 一、模板方法模式简介、 二、模板方法模式适用场景、 ...五、模板方法模式相关设计模式、 六、模板方法模式代码示例、 1、模板方法抽象类、 2、模板方法实现类 1、 3、模板方法实现类 2、 4、测试类、
  • 模板方法设计模式(Template Pattern)

    千次阅读 2020-05-17 19:45:09
    这种类型的设计模式属于行为型模式。 意图 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 主要解决 一些方法通用,却在每...
  • Java设计模式之——模板方法模式

    千次阅读 2021-12-02 14:42:31
    Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses ...模板方法模式(Template Method Pattern):定义一个操作中的算法的框架, 而将.
  • 模板方法模式是设计模式行为型中最简单的一种设计模式。在实际中你甚至可能经常用到,只是你自己不知道它是一种设计模式罢了。 模板方法模式定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得...
  • 设计模式模板方法模式,这份文档以例子的形式介绍了模板方法模式
  • java设计模式模板方法模式

    千次阅读 2022-04-09 16:37:53
    模板方法模是定义一个操作中的算法的框架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
  • 设计模式中,模板方法模式中模板和生活中模板概念非常类似,下面让我们就详细介绍模板方法的定义,大家可以根据生活中模板的概念来理解模板方法的定义。 二、模板方法模式详细介绍 2.1 模板方法模式的定义 模板...
  • 本文实例讲述了javascript设计模式模板方法模式原理与用法。分享给大家供大家参考,具体如下: 介绍:模板方法模式是结构最简单的行为型设计模式,在其结构中只存在父类与子类之间的继承关系。使用模板方法模式...
  • Java设计模式之——模板方法

    千次阅读 2022-01-27 14:59:27
    模板方法(Template Method)作为Java的设计模式之一,一个词概括其优势特点那就是:抽象步骤 接下来以问答的形式全面解析这个设计模式,相信你并不陌生
  • 模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式...这种类型的设计模式属于行为型模式。 模板方法模式 java demo
  • 本文实例讲述了JavaScript设计模式模板方法模式原理与用法。分享给大家供大家参考,具体如下: 一、模板方法模式:一种只需使用继承就可以实现的非常简单的模式。 二、模板方法模式由两部分组成,第一部分是抽象...
  • 模板方法模式是最为简单也最常用的设计模式之一了,它主要利用了Java的多态的特性,通过把所有的不会变化的定义放到一个抽象类(模板类)里实现,会变化的方法定义成抽象方法,再使用其子类对会变化的地方进行自定义...
  • 设计模式专题 - 模板方法设计模式

    千次阅读 2019-06-09 18:40:24
    一. 概述&场景分析 1. 设计模式分类 创建型模式:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式:适配器模式、装饰器模式、代理...2.要学模板方法设计模式,首先需要理解工厂模...
  • 模板方法设计模式是Java设计模式中很简单、应用非常广泛的的一种设计模式,该模式体现了编程的抽象思想(抽象是所有子类的共性封装), 仅仅使用了Java的继承机制。其实很可能在你写代码的过程中已经使用过了很...
  • 请使用模板方法模式完成(说明:因为模板方法模式,比较简单,很容易就想到这个方案,因此就直接使用,不再使用传统的方案来引出模板方法模式) 模板方法模式基本介绍 基本介绍 模板方法模式(Template Method ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 287,870
精华内容 115,148
关键字:

模板方法设计模式

友情链接: yuyinshouji.rar