设计模式(14):JAVA(14):设计模式（7） 模板模式

package com.woniuxy.n_template.a;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/*
     比较2个集合的增删、查询效率。
     
     ArrayList: 任意查询快 ， 增删慢 。
     底层：数组， 数组元素在内存中的存储特点是连续存放。
     恰恰是因为连续存放，所以任意查询快 ， 增删慢 。
     
     LinkedList: 任意查询慢， 增删快。
     底层：双向链表，链表元素在内存中的存储特点是不连续存放。
     恰恰是因为不连续存放，所以任意查询慢 ， 增删快 。
*/

public class Test {
    public static void main(String[] args) {
        
        System.out.println("ArrayList增加测试开始");
        long start = System.currentTimeMillis();
        List list = new ArrayList();
        for (int i = 1; i <= 1000000; i++) {
            list.add(0,"a");
        }
        long end = System.currentTimeMillis();
        System.out.println("ArrayList增加运行时间:" + (end - start));
        
        System.out.println("ArrayList查询测试开始");
        long start2 = System.currentTimeMillis();
        List list2 = new ArrayList();
        for (int i = 1; i <= 1000000; i++) {
            list2.add("a");
        }
        for(int i = 1; i <= 1000000; i++) {
            list2.get(500000);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("ArrayList查询运行时间:" + (end2 - start2));
        
    }
}

// 缺点：
// 1. 每当该替换测试的集合时，都必须修改类。
// 2. 而且有2个引起类变化的原因： 提升信息， 测试的集合类，违反单一职责。

package com.woniuxy.n_template.b;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

abstract class Template {
    
    private String name;
    
    public Template(String name) {
        this.name = name;
    }

    // 模板方法
    public void template() {
        System.out.println(name + "测试开始");
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println(name+"测试时间：" + (end - start));
    }
    
    
    public abstract void code();
}

// ===================================================================

class A extends Template {
    public A() {
        super("ArrayList增加");
    }
    @Override
    public void code() {
        List list = new ArrayList();
        for (int i = 1; i <= 100000; i++) {
            list.add(0,"a");
        }
    }
}

class B extends Template {
    public B () {
        super("ArrayList查询");
    }

    @Override
    public void code() {
        List list = new ArrayList();
        for (int i = 1; i <= 100000; i++) {
            list.add("a");
        }
        for(int i = 1; i <= 100000; i++) {
            list.get(50000);
        }
    }
}


class C extends Template {

    public C() {
        super("LinkedList增加");
    }
    @Override
    public void code() {
        List list = new LinkedList();
        for (int i = 1; i <= 100000; i++) {
            list.add(0,"a");
        }
    }
    
}

class D extends Template {

    public D() {
        super("LinkedList查询");
    }
    @Override
    public void code() {
        List list = new LinkedList();
        for (int i = 1; i <= 100000; i++) {
            list.add(0,"a");
        }
        for(int i = 1; i <= 100000; i++) {
            list.get(50000);
        }
    }
    
}

public class Test {
    public static void main(String[] args) {
        Template t = new A();
        Template t2 = new B();
        Template t3 = new C();
        Template t4 = new D();
        t.template();
        t2.template();
        t3.template();
        t4.template();
    }
}

package com.woniuxy.n_template.c;

import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

abstract class Template {
    
    private String name;
    
    public Template(String name) {
        this.name = name;
    }
    
    public boolean bb() {
        return true;
    }

    // 模板方法
    public void template() {
        System.out.println(name + "测试开始");
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println(name+"测试持续时间：" + (end - start));
        
        if(bb()) {
            System.out.println("测试时间：" + new Date() + "*************************");
        }
    }
    
    
    public abstract void code();
}

// ===================================================================

class A extends Template {
    private List list;
    public A(List list) {
        super(list.getClass().getName() + "增加");
        this.list = list;
    }
    @Override
    public void code() {
        for (int i = 1; i <= 100000; i++) {
            list.add(0,"a");
        }
    }
    
    @Override
    public boolean bb() {
        return false;
    }
    
}

class B extends Template {
    private List list;
    public B(List list) {
        super(list.getClass().getName() + "查询");
        this.list = list;
    }
    @Override
    public void code() {
        for (int i = 1; i <= 100000; i++) {
            list.add(0,"a");
        }
        for(int i = 1; i <= 100000; i++) {
            list.get(50000);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Template[] ts = new Template[] {
                new A(new ArrayList<>()),
                new A(new LinkedList<>()),
                new B(new ArrayList<>()),
                new B(new LinkedList<>()),
                new A(new Vector<>()),
        };
        
        for (Template t : ts) {
            t.template();
            System.out.println("============================");
        }
    }
}

/*
    在模板模式（Template Pattern）中，
    一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
*/