设计模式（模板模式）

Java设计模式

Java中有23种设计模式分为三大类

**创建型模式：单例模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式（5个）
作用：针对于对象的创建

行为型模式：访问者模式，模板模式，策略模式，状态模式，观察者模式，
备忘录模式，中介者模式，迭代器模式，解释器模式，命令模式，责任链模式（11个）
作用：类与对象之间的协作关系

结构型模式：适配器模式，桥接模式，组合模式，装饰模式，外观模式，
享元模式，代理模式（6个）
作用：行为性模式主要用于描述类或对象的交互以及职责分配
**

行为型（模板模式）

**概述：模板方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现。
	优点：使用模板方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足客户灵活多变的要求。
	缺点：如果算法骨架有修改的话，则需要修改抽象类。
举例：实习报告需要盖章，那个印章就是一个模板，可以盖在不同的实习报告上。**

代码体现（模板模式）

定义一个能够实现计算代码的执行时间的模板

//定义一个抽象类（当作模板使用）
public abstract class GetTime{
	//计算代码执行时间的方法
	public long countTime(){
		long start = System.currentTimeMillis();
			
       /*
       计算for循环的执行时间 
       	for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
        */
        
        /*
        计算复制文件的执行时间
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("a.avi"));
            bos = new BufferedOutputStream(new FileOutputStream("b.avi"));

            byte[] bys = new byte[1024];
            int len;
            while ((len = bis.read(bys)) != -1){
                bos.write(bys,0,len);
                bos.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        */
        //这里计算执行时间的操作是变化的，
        //比如多线程的操作，集合的操作，等等...
        //所有不能写死，应该提供一个抽象方法，具体是什么操作计算时间延迟到子类中来实现。
        code();//抽象方法
	}
	//抽象方法，延迟到子类中来实现具体需要算时间的操作
	public abstract void code();
}

定义一个类，继承上面的抽象类，由这个类实现具体需要计算时间的操作

//for循环执行时间的类
public class ForDemo extends GetTime{
	//实现抽象方法，执行具体的计算时间的操作
	 @Override
	  public void code() {
         for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
    }
}

定义一个类，继承上面的抽象类，由这个类实现具体需要计算时间的操作

//IO操作的执行时间
public class IODemo extends GetTime{
	
	//实现抽象方法，执行具体计算时间的操作
    @Override
    public void code() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("a.avi"));
            bos = new BufferedOutputStream(new FileOutputStream("b.avi"));

            byte[] bys = new byte[1024];
            int len;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);
                bos.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

定义一测试类，测试上面操作的执行时间

public class TestDemo {
    public static void main(String[] args) {
    	//父类引用指向子类的对象，多态
        GetTime gt = new ForDemo();
        //for循环执行时间
        System.out.println(gt .getTime() + "毫秒");

        gt = new IODemo();
        //IO操作执行时间
        System.out.println(gt .getTime()+"毫秒");

    }
}