精华内容
下载资源
问答
  • 模板方法模式

    2017-04-25 20:02:50
    模板方法模式

    模板方法模式在一个方法中定义了一个算法的股价,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤。

    类图

    这里写图片描述

    java代码

    // 饮料父类
    // 模板类
    public abstract class Beverage {
    
        // 制作饮料
        // 模板方法不允许子类覆盖
        // 模板方法定义了一连串的步骤,每个步骤由一个方法代表
        public final void makeBeverage() {
            boilWater();
            brew();
            if (withCondiment()) {
                addCondiment();
            }
            pourInCup();
        }
    
        // 烧水
        public void boilWater() {
            System.out.println("boiling water ... ");
        }
    
        // 冲泡
        public abstract void brew();
    
        // 加入调料
        public abstract void addCondiment();
    
        // 导入杯子
        public void pourInCup() {
            System.out.println("pouring into cup ... ");
        }
    
        // 钩子(hook)方法,可以定义是否需要调料,子类可以视情况选择是否覆盖
        public boolean withCondiment() {
            return true;
        }
    }
    
    // 咖啡类
    public class Coffee extends Beverage {
    
        private boolean flag = true;
    
        @Override
        public void brew() {
            System.out.println("dripping coffee through filter ... ");
        }
    
        @Override
        public void addCondiment() {
            System.out.println("adding sugar and milk ... ");
        }
    
        @Override
        public boolean withCondiment() {
            return flag;
        }
    
        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    }
    
    // 茶类
    public class Tea extends Beverage {
        @Override
        public void brew() {
            System.out.println("steeping the tea ... ");
        }
    
        @Override
        public void addCondiment() {
            System.out.println("adding lemon ... ");
        }
    }
    
    // 测试类
    public class Test {
    
        public static void main(String[] args) {
            new Test().test();
        }
    
        private void test() {
            // 制作咖啡
            Coffee coffee = new Coffee();
            coffee.setFlag(false);
            coffee.makeBeverage();
            // 制作茶
            Tea tea = new Tea();
            tea.makeBeverage();
        }
    }

    注:

    • 由Beverage主导一切,它拥有算法,而且保护这个算法
    • 对子类来说,Beverage类的存在,可以将代码的复用最大化
    • 算法只存在于一个地方,所以方便修改
    • 提供一个框架,新加入的饮料只要实现自己的方法就可以了
    • Beverage类专注算法本身,而有子类提供完整实现
    • 工厂方法是模板方法的一个特殊版本

    模板方法模式的变体

    排序操作java代码

    // 鸭子类
    public class Duck implements Comparable {  // 实现Comparable接口
    
        private String name;
        private int weight;
    
        public Duck(String name, int weight) {
            this.name = name;
            this.weight = weight;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getWeight() {
            return weight;
        }
    
        public void setWeight(int weight) {
            this.weight = weight;
        }
    
        @Override
        public int compareTo(Object o) {  // 实现compareTo方法
            Duck duck = (Duck) o;
            if (this.weight > duck.weight) {
                return 1;
            } else if (this.weight > duck.weight) {
                return 0;
            } else {
                return -1;
            }
        }
    }
    
    // 测试类
    public class Test {
    
        public static void main(String[] args) {
            new Test().test();
        }
    
        private void test() {
    
            Duck[] ducks = {new Duck("tom", 3), new Duck("jerry", 4), new Duck("harry", 1)};
            showDucks(ducks);
    
            // sort相当于一个模板方法
            // compareTo相当于给子类实现的抽象方法
            Arrays.sort(ducks);
            showDucks(ducks);
        }
    
        private void showDucks(Duck[] ducks) {
            for (Duck duck : ducks) {
                System.out.println("name=" + duck.getName() + "; weight=" + duck.getWeight());
            }
        }
    }

    注:

    • sort方法接受一个数组,然后调用compareTo方法比较大小排序
    • sort方法类似于一个模板
    • compareTo类似于一个抽象方法
    • 现实中总是没有那么完美的设计模式,需要作出妥协,数组不能继承

    参考文章
    1. Head First 设计模式

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,623
精华内容 6,649
关键字:

模板方法模式