没有使用模式

package com.zhss.designpattern.template;

/**
 * 不用模式的实现
 * @author zhonghuashishan
 *
 */
public class WithoutTempalteMethodPatternDemo {

	public static void main(String[] args) {
		DiscountCalculator1 calculator1 = new DiscountCalculator1();
		calculator1.calculate();
		
		DiscountCalculator2 calculator2 = new DiscountCalculator2();
		calculator2.calculate();
		
		DiscountCalculator3 calculator3 = new DiscountCalculator3();
		calculator3.calculate();
		
		// 有一个问题
		// 就是说，这个三种优惠方式计算器里面，都有一段通用的计算逻辑，是完全相同的代码
		// 但是相同的一段代码，给通过复制粘贴的方式，放到了不同的类里去
		// 一旦说，那段通用的计算逻辑，要修改，就涉及到多个类都要去修改那个代码
		// 如果你一旦忘了修改某个类中的那段代码，后果不堪设想
		// 而且到了后期，几乎没人记得清楚，那段通用逻辑代码放在了多少个类中，如果要排查，需要将很多类重新读一遍代码
		// 这就是垃圾代码，扩展性，维护性，很烂
	}
	
	public static class DiscountCalculator1 {
		
		public void calculate() {
			System.out.println("通用的计算逻辑，修改了一下");
			System.out.println("优惠计算器1的特殊计算逻辑");  
		}
		
	}
	
	public static class DiscountCalculator2 {
			
			public void calculate() {
				System.out.println("通用的计算逻辑，修改了一下");
				System.out.println("优惠计算器2的特殊计算逻辑");  
			}
			
		}
	
	public static class DiscountCalculator3 {
		
		public void calculate() {
			System.out.println("通用的计算逻辑");
			System.out.println("优惠计算器3的特殊计算逻辑");  
		}
		
	}
	
}

使用模式

package com.zhss.designpattern.template;

/**
 * 使用了模板方法模式
 * @author zhonghuashishan
 *
 */
public class TemplateMethodPatterDemo {

	public static void main(String[] args) {
		DiscountCalculator calculator1 = new DiscountCalculator1();
		calculator1.calculate();
		
		DiscountCalculator calculator2 = new DiscountCalculator2();
		calculator2.calculate();
		
		DiscountCalculator calculator3 = new DiscountCalculator3();
		calculator3.calculate();
	}
	
	public interface DiscountCalculator {
		
		void calculate();
		
	}
	
	/**
	 * 模板方法实现的精华所在
	 * @author zhonghuashishan
	 *
	 */
	public static abstract class AbstractDiscountCalculator implements DiscountCalculator {
		
		public void calculate() {
			// 完成通用的计算逻辑
			commonCalculate();
			// 完成特殊的计算逻辑
			specificCalculate();
		}
		
		private void commonCalculate() {
			System.out.println("通用的计算逻辑，修改了一下");
		}
		
		protected abstract void specificCalculate();
		
	}
	
	public static class DiscountCalculator1 extends AbstractDiscountCalculator {
		
		public void specificCalculate() {
			System.out.println("优惠计算器1的特殊计算逻辑");  
		}
		
	}
	
	public static class DiscountCalculator2 extends AbstractDiscountCalculator {
			
		public void specificCalculate() {
			System.out.println("优惠计算器2的特殊计算逻辑");  
		}
		
	}
	
	public static class DiscountCalculator3 extends AbstractDiscountCalculator {
		
		public void specificCalculate() {
			System.out.println("优惠计算器3的特殊计算逻辑");  
		}
		
	}
	
}

总结

使用场景： 对于多种不同实现的一些场景，比如说，不同的折扣类型，不同的优惠券类型，不同的商品类型，那肯定设计到不同的处理逻辑，但是可以将他们共同的基础逻辑抽取到父类当观众，然后将要子类实现的逻辑留空，交给子类去实现。
优点： 当修改通用逻辑的时候，只需要修改对应的那个抽象类即可，而不是修改所有的实现类