java 末班方法 - CSDN
  • java 模版方法模式

    2012-11-02 15:40:19
    定义:定义一个操作中算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变算法的结构即可重定义... 事实上,模版方法是编程中一个经常用到的模式。先来看一个例子,某日,程序员A拿到一个任务:给定一个整

    原文出处:http://blog.csdn.net/zhengzhb/article/details/7405608


    定义:定义一个操作中算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。

    类型:行为类模式

    类图:

            事实上,模版方法是编程中一个经常用到的模式。先来看一个例子,某日,程序员A拿到一个任务:给定一个整数数组,把数组中的数由小到大排序,然后把排序之后的结果打印出来。经过分析之后,这个任务大体上可分为两部分,排序和打印,打印功能好实现,排序就有点麻烦了。但是A有办法,先把打印功能完成,排序功能另找人做。

    [java] view plaincopy
    1. abstract class AbstractSort {  
    2.       
    3.     /** 
    4.      * 将数组array由小到大排序 
    5.      * @param array 
    6.      */  
    7.     protected abstract void sort(int[] array);  
    8.       
    9.     public void showSortResult(int[] array){  
    10.         this.sort(array);  
    11.         System.out.print("排序结果:");  
    12.         for (int i = 0; i < array.length; i++){  
    13.             System.out.printf("%3s", array[i]);  
    14.         }  
    15.     }  
    16. }  

            写完后,A找到刚毕业入职不久的同事B说:有个任务,主要逻辑我已经写好了,你把剩下的逻辑实现一下吧。于是把AbstractSort类给B,让B写实现。B拿过来一看,太简单了,10分钟搞定,代码如下:

    [java] view plaincopy
    1. class ConcreteSort extends AbstractSort {  
    2.   
    3.     @Override  
    4.     protected void sort(int[] array){  
    5.         for(int i=0; i<array.length-1; i++){  
    6.             selectSort(array, i);  
    7.         }  
    8.     }  
    9.       
    10.     private void selectSort(int[] array, int index) {  
    11.         int MinValue = 32767// 最小值变量  
    12.         int indexMin = 0// 最小值索引变量  
    13.         int Temp; // 暂存变量  
    14.         for (int i = index; i < array.length; i++) {  
    15.             if (array[i] < MinValue){ // 找到最小值  
    16.                 MinValue = array[i]; // 储存最小值  
    17.                 indexMin = i;   
    18.             }  
    19.         }  
    20.         Temp = array[index]; // 交换两数值  
    21.         array[index] = array[indexMin];  
    22.         array[indexMin] = Temp;  
    23.     }  
    24. }  

    写好后交给A,A拿来一运行:

    [java] view plaincopy
    1. public class Client {  
    2.     public static int[] a = { 1032195712043 }; // 预设数据数组  
    3.     public static void main(String[] args){  
    4.         AbstractSort s = new ConcreteSort();  
    5.         s.showSortResult(a);  
    6.     }  
    7. }  

    运行结果:

    排序结果:  0  1  3  4  5  7  9 10 12 32

            运行正常。行了,任务完成。没错,这就是模版方法模式。大部分刚步入职场的毕业生应该都有类似B的经历。一个复杂的任务,由公司中的牛人们将主要的逻辑写好,然后把那些看上去比较简单的方法写成抽象的,交给其他的同事去开发。这种分工方式在编程人员水平层次比较明显的公司中经常用到。比如一个项目组,有架构师,高级工程师,初级工程师,则一般由架构师使用大量的接口、抽象类将整个系统的逻辑串起来,实现的编码则根据难度的不同分别交给高级工程师和初级工程师来完成。怎么样,是不是用到过模版方法模式?

     

    模版方法模式的结构

           模版方法模式由一个抽象类和一个(或一组)实现类通过继承结构组成,抽象类中的方法分为三种:

    • 抽象方法:父类中只声明但不加以实现,而是定义好规范,然后由它的子类去实现。
    • 模版方法:由抽象类声明并加以实现。一般来说,模版方法调用抽象方法来完成主要的逻辑功能,并且,模版方法大多会定义为final类型,指明主要的逻辑功能在子类中不能被重写。
    • 钩子方法:由抽象类声明并加以实现。但是子类可以去扩展,子类可以通过扩展钩子方法来影响模版方法的逻辑。
    • 抽象类的任务是搭建逻辑的框架,通常由经验丰富的人员编写,因为抽象类的好坏直接决定了程序是否稳定性。

           实现类用来实现细节。抽象类中的模版方法正是通过实现类扩展的方法来完成业务逻辑。只要实现类中的扩展方法通过了单元测试,在模版方法正确的前提下,整体功能一般不会出现大的错误。

     

    模版方法的优点及适用场景

           容易扩展。一般来说,抽象类中的模版方法是不易反生改变的部分,而抽象方法是容易反生变化的部分,因此通过增加实现类一般可以很容易实现功能的扩展,符合开闭原则。

           便于维护。对于模版方法模式来说,正是由于他们的主要逻辑相同,才使用了模版方法,假如不使用模版方法,任由这些相同的代码散乱的分布在不同的类中,维护起来是非常不方便的。

           比较灵活。因为有钩子方法,因此,子类的实现也可以影响父类中主逻辑的运行。但是,在灵活的同时,由于子类影响到了父类,违反了里氏替换原则,也会给程序带来风险。这就对抽象类的设计有了更高的要求。

           在多个子类拥有相同的方法,并且这些方法逻辑相同时,可以考虑使用模版方法模式。在程序的主框架相同,细节不同的场合下,也比较适合使用这种模式

    展开全文
  • java的模板类

    2013-01-09 16:15:46
    java的模板类可以理解为含有Object类型的类。   1. java的模板类的模板参数只能是参数类型,成员变量类型等,模板名是确定的。 2. 运行期,模板参数会被当作Object来处理,已经验证 3. 使用模板类的类型安全,...

    java的模板类可以理解为含有Object类型的类。

     

    1. java的模板类的模板参数只能是参数类型,成员变量类型等,模板名是确定的。

    2. 运行期,模板参数会被当作Object来处理,已经验证

    3. 使用模板类的类型安全,只是利用编译器的类型检查,来自动保证运行期的类型强转的正确与安全。

    上一篇:UI layout设置技巧下一篇:Android 动画框架详解


    class  TestTemplate
    {
    	public static void main(String[] args) 
    	{
    		//vector<T> v=new vector<T>(); 
    		Byte b=new Byte((byte)0);
    		vector<Byte> v=new vector<Byte>(b);
    		v.add((byte)0);
    		v.add((byte)1);
    		v.add((byte)3);
    		v.add((byte)2);
    		v.visitAll();
    		
    	}
    }
    
    class vector<T>{
    
    	private int size=0;
    	private vectorElement<T> head=null;
    	private vectorElement<T> last=null;
    
    	public vector(T datum)
    	{
    		System.out.println("vector(T datum)!");
    		this.head=new vectorElement<T>(datum);
    		this.last=this.head;
    		this.size=1; 
    	}
    
    
    public boolean add(T datum){
    
    		if(this.size==0){
    			this.head=new vectorElement<T>(datum);
    			this.last=this.head;
    			this.size=1;
    		}else{
    			vectorElement<T> temp=new vectorElement<T>(datum);
    			temp.previous=this.last;
    			this.last.next=temp;
    			this.last=temp;
    			this.size=this.size+1;
    		}
    		return true;
    
    	}
    
    	public void visitAll()
    	{
    		vectorElement<T> walker;
    		walker=head;
    		while(walker !=null)
    		{
    			System.out.println(walker.datum);
    			walker=walker.next;
    		}
    	}
    }
    
    class vectorElement<T>{
    
    	public vectorElement<T> next=null;
    	public vectorElement<T> previous=null;
    	public T datum=null;
    
    	public vectorElement(T datum){ this.datum=datum; }
    
    }
    
    /*
    vector(T datum)!
    0
    0
    1
    3
    2
    请按任意键继续. . .
    */
    


    展开全文
  • Java 模板模式

    2019-01-23 16:16:50
    模板模式的定义:  它定义了一个操作中的算法骨架,将某些步骤延迟到子类中实现,这样子类...模板方法的角色:  1.抽象模板角色:它一般是一个抽象类或者接口,它抽象出操作算法骨架。  2.具体抽象模板角色:...

    模板模式的定义:

           它定义了一个操作中的算法骨架,将某些步骤延迟到子类中实现,这样子类才可以不改变算法结构的前提下重新定义改算法的某些特定步骤。

    模板模式的核心:

           处理的步骤父类中早已定义好,具体的实现延迟到子类中去完成。

    模板方法的角色:

           1.抽象模板角色:它一般是一个抽象类或者接口,它抽象出操作算法骨架。

           2.具体抽象模板角色:它实现了抽象模板角色的方法,它是操作算法骨架业务的具体化。

    模板方法的优点:

            1.封装不变部分,扩展可变部分。

             2.提取了公共代码,便于维护。

              3.行为由父类控制,子类实现。

    模板方法的缺点:

             1.每一个不同的实现都需要一个子类来实现,这样导致类的个数增加。

    模板模式的使用场景:      

              1.实现一个算法时,基本步骤很固定,但是某些部分易变,易变的部分可以抽离出来,由子类实现。

     

    平常我们在面馆是下单,吃面,付钱,在烧烤店,下单,吃烧烤,付钱。在面馆和烧烤店,我们就吃的食物不一样,所以我们下面可以用这个来演示我们的模板模式。

    /**
     * 抽象模板角色
     * @author Administrator
     */
    
    public abstract class Template {
        public void oreder(){
            Log.d("templateTest","先下订单");
        }
    
        abstract void eatFood();
    
        public void payMoney(){
            Log.d("templateTest","吃完付钱");
        }
    
        //模板方法,final修饰的方法,不可以被子类重写
        public final  void process(){
            this.oreder();
            this.eatFood();
            this.payMoney();
        }
    }
    

     

    /**
     * 具体模板角色(面馆)
     * @author Administrator
     */
    
    public class NoodleShop extends Template{
        @Override
        void eatFood() {
            Log.d("templateTest","我在面馆吃面");
        }
    }
    

     

    /**
     * 具体模板角色(烧烤店)
     * @author Administrator
     */
    public class BarbecueShop extends Template {
        @Override
        void eatFood() {
            Log.d("templateTest","我在烧烤店吃烧烤");
        }
    }
    

    客户端调用:

    //在面馆吃面
    Template eatNoodle=new NoodleShop();
    eatNoodle.process();

    结果:

     

    //在烧烤店吃烧烤
    Template eatBarbecue=new BarbecueShop();
    eatBarbecue.process();

    结果:

    其实上面的调用,还可以用匿名内部类的方式来调用,能起到一样的效果。

    Template eatNoodle= new Template() {
         @Override
         void eatFood() {
              Log.d("templateTest","我在面馆吃面");
         }
    };
    eatNoodle.process();
    
    Template eatBarbecue= new Template() {
         @Override
         void eatFood() {
              Log.d("templateTest","我在烧烤店吃烧烤");
         }
    };
    eatBarbecue.process();
    展开全文
  • Velocity是一个基于java的模板引擎(template engine)。它允许任何人仅仅简单的使用模板语言(template language)来引用由java代码定义的对象。 当Velocity应用于web开发时,界面设计人员可以和java程序开发人员...

    Velocity是一个基于java的模板引擎(template engine)。它允许任何人仅仅简单的使用模板语言(template language)来引用由java代码定义的对象。

    当Velocity应用于web开发时,界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点,也就是说,页面设计人员可以只关注页面的显示效果,而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来,这样为web站点的长期维护提供了便利,同时也为我们在JSP和PHP之外又提供了一种可选的方案。

    Velocity的能力远不止web站点开发这个领域,例如,它可以从模板(template)产生SQL和PostScript、XML,它也可以被当作一个独立工具来产生源代码和报告,或者作为其他系统的集成组件使用。Velocity也可以为Turbine web开发架构提供模板服务(template service)。Velocity+Turbine提供一个模板服务的方式允许一个web应用以一个真正的MVC模型进行开发。

    展开全文
  • java个人简历模板

    2020-07-30 23:32:33
    java个人简历模板
  • Java模板模式

    2018-12-29 16:19:40
    多个子类有公有的方法,并且逻辑基本相同时 重要,复杂的算法,可以放到模板,周边相关的细节交给子类 重构时,把相同的的模板提出到父类中,然后通过钩子函数约束其行为 /** * 模板 * * @author ...
  • 超级好用的 java 注释模板,吐血总结,整理。吐血总结,整理。
  • 新一代Java模板引擎Thymeleaf Thymeleaf是一款用于渲染XML/XHTML/HTML5内容的模板引擎。类似JSP,Velocity,FreeMaker等,它也可以轻易的与Spring MVC等Web框架进行集成作为Web应用的模板引擎。与其它模板引擎相比...
  • java简历模板大集合

    2020-07-01 18:44:54
    各种简历模板。中英文的都有,主流是java开发。还有求职说明!
  • java接口填写模板

    2018-07-23 09:33:33
    java接口填写模板 java接口填写模板要点要有: 1.接口名称 2.请求地址 3.接口说明 4.接口提供者 5.接口使用者 6.参数说明 6.1参数详情 7.返回值说明 7.1返回值参数详解详情   ...
  • java注释模版

    2014-12-11 15:36:20
    每个类,接口,函数都写上注释是良好的编程习惯。 这样以后自己查看代码时也能很快的理解其中的意思。 注释模版 下面给出注释的模版,直接复制粘贴到函数前面即可。...*Description: XXXX DRIVER 3
  • JAVA 类注释模板

    2019-12-27 16:47:00
    /** *author ${USER} * Date ${DATE} ${TIME} * Description */
  • 如图所示 我的模板是这个 /** * @Description * @Author HuHuanJin * @Date ${YEAR}-${MONTH}-${DAY} ${TIME} */ ...下面附上内置的一些参数 ...${PACKAGE_NAME} - 将在其中创建新类或接口的目标包的名称 ...
  • 1. 面试指南 这篇文章还在更新,正在孵化,但是你可以借鉴是这里面的一点点经验…持续更新! 2. 简历的书写 HR筛选简历时,一般来说非常的快,可能你的简历10秒就被看完了。所以,简历要简单干脆 ...
  • Java模板方法设计模式

    2017-06-16 07:38:16
    模板方法设计模式 在现实生活中,完成某件事是需要n多个固定步骤的。如"在淘宝网进行购物"这件事情的完成一般需要三个步骤:登录网站、挑选商品、付款。但对于每个人几乎都是相同的操作,但不同的地方是,每个人挑选...
  • 推荐一个Java后台系统Bootstrap模板 这个模板是我们公司专门用来做后台系统的,简单,漂亮,不会前端的也可以做 下载地址:https://download.csdn.net/download/qq_21683643/10316430...
  • 该项目为Java web实现的数据导出到Excel小案例,采用了POI进行处理。
  • JAVA 中excel的上传下载

    2020-03-26 23:30:45
    JAVA 中excel的上传下载
  • 在下载word模板.rtf过程中,将模板中约定的标识内容替换为需要的信息。省时省力很方便。
  • java vm(velocity)模板

    2020-02-24 11:51:48
     Velocity是一个基于java的模板引擎(template engine)。它允许任何人仅仅简单的使用模板语言(template language)来引用由java代码定义的对象。  当Velocity应用于web开发时,界面设计人员可以和java程序开发...
1 2 3 4 5 ... 20
收藏数 832
精华内容 332
热门标签
关键字:

java 末班方法