java设计模式之——模版方法

例如，需要把book类包装成xml，json等格式的数据，

book类：

public class Book {  

    private String bookName;  

    private int pages;  

    private double price;  

    private String author;  

    private String isbn;  

    public String getBookName() {  
        return bookName;  
    }  

    public void setBookName(String bookName) {  
        this.bookName = bookName;  
    }  

    public int getPages() {  
        return pages;  
    }  

    public void setPages(int pages) {  
        this.pages = pages;  
    }  

    public double getPrice() {  
        return price;  
    }  

    public void setPrice(double price) {  
        this.price = price;  
    }  

    public String getAuthor() {  
        return author;  
    }  

    public void setAuthor(String author) {  
        this.author = author;  
    }  

    public String getIsbn() {  
        return isbn;  
    }  

    public void setIsbn(String isbn) {  
        this.isbn = isbn;  
    }  

}  

首先在一个抽象类中定义一个抽象方法：

public abstract class Formatter {  

    public String formatBook(Book book, int format) {  
        beforeFormat();  
        String result = formating(book);  
        afterFormat();   
    }  

   protected void beforeFormat() {  
        System.out.println("format begins");  
    }  

    protected abstract String formating(Book book);  

    protected void afterFormat() {  
        System.out.println("format finished");  
    }  
}  

你会发现format_book方法只有四步，第一步调用before_format，去打印格式转换前的日志。第二步调用formating，这个方法是个抽象方法，用于处理具体的转换逻辑，因此每一个继承自Formatter的子类都需要重写此方法，来实现各自的转换逻辑。第三步调用after_format，去打印格式转换后的日志。第四步返回result。由于类中存在了抽象方法，我们也就需要把Formatter声明成抽象类。

这样之后如果想要包装json格式的数据就可以写一个类继承自抽象类，然后重写抽象方法：

public class JSONFormatter extends Formatter {  

    @Override  
    protected String formating(Book book) {  
        String result = "";  
        result += "{\n";  
        result += "\"book_name\" : \"" + book.getBookName() + "\",\n";  
        result += "\"pages\" : \"" + book.getPages() + "\",\n";  
        result += "\"price\" : \"" + book.getPrice() + "\",\n";  
        result += "\"author\" : \"" + book.getAuthor() + "\",\n";  
        result += "\"isbn\" : \"" + book.getIsbn() + "\",\n";  
        result += "}";  
        return result;  
    }  

   //在执行父类的beforeFormat()之后，执行子类的逻辑
   @Override
    protected void beforeFormat() {
        super.beforeFormat();
        System.out.println("JSONFormatter format begins");
    }

    @Override
    protected void afterFormat() {
        super.afterFormat();
        System.out.println("JSONFormatter format finished");
    }
}  

如果想要包装xml格式的数据：

public class XMLFormatter extends Formatter {  

    @Override  
    protected String formating(Book book) {  
        String result = "";  
        result += "<book_name>" + book.getBookName() + "</book_name>\n";  
        result += "<pages>" + book.getPages() + "</pages>\n";  
        result += "<price>" + book.getPrice() + "</price>\n";  
        result += "<author>" + book.getAuthor() + "</author>\n";  
        result += "<isbn>" + book.getIsbn() + "</isbn>\n";  
        return result;  
    }  

}  

最后在使用的时候：

public class Test {  

    public static void main(String[] args) throws Exception {  
        Book book = new Book();  
        book.setBookName("Thinking in Java");  
        book.setPages(880);  
        book.setPrice(68);  
        book.setAuthor("Bruce Eckel");  
        book.setIsbn("9787111213826");  
        XMLFormatter xmlFormatter = new XMLFormatter();  
        String result = xmlFormatter.formatBook(book);  
        System.out.println(result);  
        JSONFormatter jsonFormatter = new JSONFormatter();  
        result = jsonFormatter.formatBook(book);  
        System.out.println(result);  
    }  

}  

这样做的好处就是可以灵活的添加各种包装格式，如果想要包装成一中新格式就可以在写一个包装类继承自Formatter。

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

android中典型的模版方法模式：新建一个Actiivty时都会覆盖onCreate、onResume等生命周期方法，这些方法是在父类中定义好的模板，会由系统自动回调，我们可以通过重写来替换掉这些方法，却无法改变他们的调用顺序。

如果还不明白，参考郭神的文章http://blog.csdn.net/guolin_blog/article/details/8744002