Java23种设计模式

设计模式并非类库，但类库中使用了设计模式

● java.util.Iterator是用于遍历元素集合的接口，这里使用了Iterator模式

● java.util.Observer是用于观察对象状态变化的接口，这里使用了Observer模式

● 以下的方法中使用了Factory Method模式

java.util.Calender类的getInstance方法

java.secure.SecureRandom类的getInstance方法

java.text.NumberFormat类的getInstance方法

● java.awt.Component和java.awt.Container这两个类中使用了Composite模式

 

第一部分 适应设计模式

第一章：Iterator模式---一个一个遍历：用于在数据集合中按照顺序遍历集合，迭代器

       Iterator模式中的登场角色

       ◆Iterator(迭代器)

       ◆ConcreteIterator(具体的迭代器)

       ◆Aggregate(集合)

       ◆ConcreteAggregate(具体的集合)

       不管实现如何变化,都可以使用Iterator：设计模式的作用就是帮助我们编写可复用性的类。

       所谓的“可复用”,就是指将类实现为“组件”，当一个组件发生改变时，不需要对其他的组件进行修改或是只需很小的修改即可应对。

       难以理解抽象类和接口：不要只使用具体类来编程，要优先使用抽象类和接口来编程

       Aggregate和Iterator的对应

       容易弄错“下一个”

       next方法是“返回当前的元素，并指向下一个元素”

       还容易弄错“最后一个”

       hasNext方法在返回最后一个元素前会返回true,当返回了最后一个元素后则返回false，作用是“确认接下来是否可以调用next方法”

       多个Iterator

      “将遍历功能置于Aggregate角色之外”是Iterator模式的一个特征。

        根据这个特征，可以针对一个ConcreteAggregate角色编写多个ConcreteIterator角色。

       迭代器的种类多种多样

       遍历的方法 •从最后开始向前遍历 •既可以从前向后遍历，也可以从后向前遍历(既有next方法也有previous方法)

       •指定下标进行“跳跃式”遍历

      不需要deleteIterator

      没有被使用的对象实例将会自动被删除(垃圾回收,GC)。

       相关的设计模式

       ◆Visitor模式

         Iterator模式是从集合中一个一个取出元素进行遍历，但是并没有在Iterator接口中声明对取出的元素进行何种处理。

         Visitor模式则是在遍历元素集合的过程中，对元素进行相同的处理。

       ◆Composite模式

         Composite模式是具有递归结构的模式，在其中使用Iterator模式比较困难。

       ◆Factory Method模式

         在Iterator方法中生成Iterator的实例时可能会使用Factory Method模式。

  /**
    *定义Book类,定义构造方法并初始化
    */
    public class Book
    {
        private String name;
        public Book(String name) {
            this.name = name;
        }                 
        public String getName() {
            return name;
        }
    }

    /**
    *定义BookShelf类
    */
    import java.util.ArrayList;

    /*public class BookShelf implements Aggregate
    {
        private Book[] books;
        private int last = 0;
        public BookShelf(int maxsize) {
            this.books = new Book[maxsize];
        }
        public Book getBookAt(int index) {
            return books[index];
        }
        public void appendBook(Book book) {
            this.books[last] = book;
            last++;
        }
        public int getLength() {
            return last;
        }
        public Iterator iterator() {
            return new BookShelfIterator(this);
        }
    }*/
    /**
    *当书的数量超过最初指定的书架容量时,就无法继续向书架中添加书本了。
    *编写用java.util.ArrayList修改程序
    */
    public class BookShelf implements Aggregate 
    {
        private ArrayList books;
        public BookShelf(int initialsize) {
            this.books = new ArrayList(initialsize);
        }
        public Book getBookAt(int index) {
            return (Book)books.get(index);
        }
        public void appendBook(Book book) {
            books.add(book);
        }
        public int getLength() {
            return books.size();
        }
        public Iterator iterator() {
            return new BookShelfIterator(this);
        }
    }

    /**
    *表示集合的接口,该方法会生成一个用于遍历集合的迭代器
    */
    public interface Aggregate
    {
        public abstract Iterator iterator();
    }

    /**
    *定义Iterator接口用于遍历集合中的元素
    *其作用相当于循环语句中的循环变量
    */
    public interface Iterator
    {
        /*当集合中存在下一个元素时,该方法返回true;
        当集合中不存在下一个元素,即已经遍历至集合末尾时,该方法返回false
        hasNext方法主要用于循环终止条件*/
        public abstract boolean hasNext();
        /*该方法返回的是集合中的一个元素,也可以返回下一个元素*/
        public abstract Object next();
    }

    /**
    *定义BookShelfIterator类
    */
    public class BookShelfIterator implements Iterator
    {
        private BookShelf bookShelf;
        private int index;
        public BookShelfIterator(BookShelf bookShelf) {
            this.bookShelf = bookShelf;
            this.index = 0;
        }
        public boolean hasNext() {
            if(index < bookShelf.getLength()) {
                return true;
            } else {
                return false;
            }
        }
        public Object next() {
            Book book = bookShelf.getBookAt(index);
            index++;
            return book;
        }
    }

    /**
    *测试类Main
    */
    public class Main
    {
        public static void main(String[] args) {
            BookShelf bookShelf = new BookShelf(4);
            bookShelf.appendBook(new Book("Around the World in 80 Days"));
            bookShelf.appendBook(new Book("Bible"));
            bookShelf.appendBook(new Book("Cinderella"));
            bookShelf.appendBook(new Book("Daddy-Long-Legs"));
            bookShelf.appendBook(new Book("East of Eden"));
            bookShelf.appendBook(new Book("Frankenstein"));
            bookShelf.appendBook(new Book("Gulliver's Travels"));
            bookShelf.appendBook(new Book("Hamlet"));
            Iterator it = bookShelf.iterator();
            while(it.hasNext()) {
                Book book = (Book)it.next();
                System.out.println(book.getName());
            }
        }
    }

第二章：Adapter模式---加个“适配器”以便于复用

      ●类适配器模式(使用继承的适配器)

      ●对象适配器模式(使用委托的适配器)

Adapter模式中的登场角色

◆Target(对象)-->Print类

◆Client(请求者)-->Main类

◆Adaptee(被适配)-->Banner类

◆Adapter(适配)-->PrintBanner类

在类适配器模式中，Adapter角色通过继承来使用Adaptee角色，而在对象适配器模式中，Adapter角色通过委托来使用Adaptee角色。委托指将某个方法中的实例处理交给其他实例的方法。

什么时候使用Adapter模式

Adapter模式会对现有的类进行适配，生成新的类。通过该模式可以很方便地创建我们需要的方法群。当出现Bug时，由于我们很明确地知道Bug不在现有的类(Adaptee角色)中，所以只需调查扮演Adapter角色的类即可。这样一来，代码问题的排查就会变得非常简单。

如果没有现成的代码

使用Adapter模式可以在完全不改变现有代码的前提下使现有代码适配于新的接口(API)。此外，在Adapter模式中，并非一定需要现成的代码。只要知道现有类的功能，就可以编写出新的类。

版本升级与兼容性

功能完全不同的类

Adaptee角色和Target角色的功能完全不同时，Adapter模式无法使用。

相关的设计模式

◆Bridge模式

Adapter模式用于连接接口(API)不同的类，而Bridge模式则用于连接类的功能层次结构与实现层次结构。

◆Decorator模式

Adapter模式用于填补不同接口(API)之间的缝隙，而Decorator模式则是在不改变接口(API)的前提下增加功能。

    /**
    *Banner类
    */
    public class Banner
    {
        private String string;
        public Banner(String string) {
            this.string = string;
        }
        public void showWithParen() {
            System.out.println("(" + string + ")");
        }
        public void showWithAster() {
            System.out.println("*" + string + "*");
        }
    }

 
    /**
    *定义FileIO接口(Target角色)中声明了将属性集合保存至文件的方法,
    *并假设FileProperties类会实现这个FileIO接口
    */
    import java.io.*;
    public interface FileIO
    {
        public void readFormFile(String filename) throws IOException;
        public void writeToFile(String filename) throws IOException;
        public void setValue(String key, String value);
        public String getValue(String key);
    }

    /**
    *Print接口是"需求"的接口
    *使用继承的适配器
    */
    /*public interface Print
    {
        public abstract void printWeak();
        public abstract void printStrong();
    }*/
    /**
    *使用委托的适配器
    */
    public abstract class Print
    {
        public abstract void printWeak();
        public abstract void printStrong();
    }

    /**
    *PrintBanner类扮演适配器的角色
    *使用继承的适配器
    */
    /*public class PrintBanner extends Banner implements Print
    {
        public PrintBanner(String string) {
            super(string);
        }
        public void printWeak() {
            showWithParen();
        }
        public void printStrong() {
            showWithAster();
        }
    }*/
    /**
    *使用委托的适配器
    */
    public class PrintBanner  extends Print
    {                                     
        private Banner banner;
        public PrintBanner(String string) {
            this.banner = new Banner(string);
        }
        public void printWeak() {
            banner.showWithParen();
        }
        public void printStrong() {
            banner.showWithAster();
        }
    }

    /**
    *用Adapter模式将一个属性集合保存至文件中的FileProperties类
    */
    import java.io.*;
    import java.util.*;
    public class FileProperties extends Properties implements FileIO
    {
        public void readFormFile(String filename) throws IOException {
            load(new FileInputStream(filename));
        }
        public void writeToFile(String filename) throws IOException {
            store(new FileOutputStream(filename),"written by FileProperties");
        }
        public void setValue(String key,String value) {
            setProperty(key,value);
        }
        public String getValue(String key) {
            return getProperty(key,"");
        }
    }

    /**
    *Main类是通过扮演适配器角色的PrintBanner类来弱化(带括号)
    *或是强化Hello(带*号)字符串的显示
    */
    /*public class Main
    {
        public static void main(String[] args) {
            Print p = new PrintBanner("Hello");
            p.printWeak();
            p.printStrong();
        }
    }*/
    import java.io.*;
    public class Main
    {
        public static void main(String[] args) {
            FileIO f = new FileProperties();
            try {
                f.readFormFile("file.txt");
                f.setValue("year","2017");
                f.setValue("month","6");
                f.setValue("day","9");
                f.writeToFile("newfile.txt");
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }

file.txt

year=1995

生成的newfile.txt

#written by FileProperties
#Fri Jun 09 20:04:48 CST 2017
day=9
year=2017
month=6

第三章：Template Method模式---将具体处理交给子类

       在父类中定义处理流程的框架，在子类中实现具体处理的模式

◆AbstractClass(抽象类)

AbstractClass角色不仅负责实现模板方法，还负责声明在模板方法中所用的抽象方法。这些抽象方法由子类负责ConcreteClass角色负责实现。

◆ConcreteClass(具体类)

    该角色负责具体实现AbstractClass角色中定义的抽象方法。这里实现的方法将会在AbstractClass角色的模板方法中被调用。

可以使逻辑处理通用化

父类与子类之间的协作

父类与子类的一致性

使用父类类型的变量保存子类实例的优点是，即使没有用instanceof等指定子类的种类，程序也能正常工作。

无论在父类类型的变量中保存哪个子类的实例，程序都可以正常工作，这种原则称为里氏替换原则(LSP)。它是通用的继承原则。

相关的设计模式

◆Factory Method模式

Factory Method模式是将Template Method模式用于生成实例的一个典型例子。

◆Strategy模式

在Template Method模式中，可以使用继承改变程序的行为。这是因为Template Method模式在父类中定义程序行为的框架，在子类中决定具体的处理。

与此相对的是Strategy模式，它可以使用委托改变程序的行为。与Template Method模式中改变部分程序行为不同的是，Strategy模式用于替换整个算法。

父类对子类的要求

◆在子类中可以使用父类中定义的方法

◆可以通过在子类中增加方法以实现新的功能

◆在子类中重写父类的方法可以改变程序的行为

声明抽象方法的目的：

◆期待子类去实现抽象方法

◆要求子类去实现抽象方法

抽象类的意义

父类与子类的协作

    /**
    *只实现了display方法的抽象类
    */
    public abstract class AbstractDisplay
    {
        public abstract void open();//交给子类去实现的抽象方法
        public abstract void print();//交给子类去实现的抽象方法
        public abstract void close();//交给子类去实现的抽象方法
        public final void display() {//本抽象类中实现的display方法
            open();//首先打开
            for(int i = 0; i < 5; i++) {
                print();
            }
            close();//然后关闭
        }
    }

    /**
    *实现了open、print、close方法的类
    */
    public class CharDisplay extends AbstractDisplay
    {
        private char ch;//需要显示的字符
        public CharDisplay(char ch) {
            this.ch = ch;
        }
        public void open() {
            System.out.print("<<");
        }
        public void print() {
            System.out.print(ch);
        }
        public void close() {
            System.out.print(">>");
        }
    }

    /**
    *实现了open、print、close方法的类
    */
    public class StringDisplay extends AbstractDisplay
    {
        private String string; //需要显示的字符串
        private int width;//以字节为单位计算出的字符串长度
        public StringDisplay(String string) {
            this.string = string;
            this.width = string.getBytes().length;
        }
        public void open() {
            printLine();
        }
        public void print() {
            System.out.println("|" + string + "|");
        }
        public void close() {
            printLine();
        }
        private void printLine() {
            System.out.print("+");//显示表示方框的角的"+"
            for(int i = 0; i < width; i++) {
                System.out.print("-");
            }
            System.out.println("+");
        }
    }

    /**
    *测试程序行为的类
    */
    public class Main
    {
        public static void main(String[] args) {
            //生成一个持有'H'的CharDisplay类的实例
            AbstractDisplay d1 = new CharDisplay('H');
            //生成一个持有"Hello World!"的StringDisplay类的实例
            AbstractDisplay d2 = new StringDisplay("Hello World!");
            AbstractDisplay d3 = new StringDisplay("你好 世界！");
            d1.display();
            d2.display();
            d3.display();
        }
    }

第四章：Factory Method模式---将实例的生成交给子类

        Factory Method模式中，父类决定实例的生成方式，但并不决定所要生成的具体的类，具体的处理全部交给子类负责。

        这样就可以将生成实例的框架和实际负责生成实例的类解耦。

        Factory Method模式中的登场角色

◆Product(产品)

◆Creator(创建者)

不用new关键字来生成实例，而是调用生成实例的专用方法来生成实例，这样就可以防止父类与其他具体类耦合。

◆ConcreteProduct(具体的产品)

◆ConcreteCreator(具体的创建者)

生成实例-----方法的三种实现方式

◆指定其为抽象方法

abstract class Factory {

          public abstract Product createProduct(String name);

          …

       }

◆为其实现默认处理

 class Factory {

    public Product createProduct(String name) {

          return new Product(name)；

    }

…

 }

不过，这时是使用new关键字创建出实例的，因此不能将Product类定义为抽象类。

◆在其中抛出异常

 class Factory {

    public Product createProduct(String name) {

       throw new FactoryMethodRuntimeException();

}

…}

不过，需要另外编写FactoryMethodRuntimeException异常类

相关的设计模式

◆Template Method模式

Factory Method模式是Template Method 的典型应用。在示例程序中，create方法就是模板方法。

◆Singleton模式

在多数情况下我们可以将Singleton模式用来扮演Creator角色(或是ConcerteCreator角色)的类。

◆Composite模式

有时可以将Composite模式用于Product角色(或是ConcerteProduct角色)

◆Iterator模式

有时，在Iterator模式中使用iterator方法生成Iterator的实例时会用Factory Method模式。

    /**
    *只定义抽象方法use的抽象类
    */
    package framework;//生成实例的框架(framework包)
                                        
    public abstract class Product
    {
        public abstract void use();
    }

    /**
    *实现了create方法的抽象类
    */
    package framework;

    public abstract class Factory
    {
        public final Product create(String owner) {
            Product p = createProduct(owner);
            registerProduct(p);
            return p;
        }
        protected abstract Product createProduct(String owner);
        protected abstract void registerProduct(Product product);
    }

    /**
    *实现了use方法的类
    */
    package idcard;
    import framework.*;

    public class IDCard extends Product
    {
        private String owner;
        private int serial;
        IDCard(String owner, int serial) {
            System.out.println("制作" + owner + "(" + serial + ")" + "的ID卡。");
            this.owner = owner;
        }
        public void use() {
            System.out.println("使用" + owner + "(" + serial + ")" + "的ID卡。");
        }
        public String getOwner() {
            return owner;
        }
        public int getSerial() {
            return serial;
        }
    }

    /**
    *实现了createProduct、registerProduct方法的类
    */
    package idcard;
    import framework.*;
    import java.util.*;

    public class IDCardFactory extends Factory
    {
        /*private List owners = new ArrayList();
        protected Product createProduct(String owner) {
            return new IDCard(owner);
        }
        protected void registerProduct(Product product) {
            owners.add(((IDCard)product).getOwner());
        }
        public List getOwners() {
            return owners;
        }*/
        private HashMap database = new HashMap();
        private int serial = 100;
        protected synchronized Product createProduct(String owner) {
            return new IDCard(owner,serial++);
        }
        protected void registerProduct(Product product) {
            IDCard card = (IDCard)product;
            database.put(new Integer(card.getSerial()),card.getOwner());
        }
        public HashMap getDatabase() {
            return database;
        }
    }

    /**
    *测试程序行为的类
    */
    import framework.*;
    import idcard.*;

    public class Main
    {
        public static void main(String[] args) {
            Factory factory = new IDCardFactory();
            Product card1 = factory.create("小明");
            Product card2 = factory.create("小红");
            Product card3 = factory.create("小刚");
            card1.use();
            card2.use();
            card3.use();
        }
    }