设计模式——Abstract Factory（抽象工厂）模式

抽象的零件：Item类

Item类是Link和Tray类的父类，这样Link和Tray类就具有可替换性了。
caption字段表示项目的“标题”
makeHTML方法是抽象，需要子类来实现这个方法。该方法会返回HTML文件的内容（需要子类去实现）

package factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}

抽象的零件类：Link类

Link类是抽象地表示HTML的超链接的类。
url字段中保存的是超链接所指向的地址。乍一看，在Link类中好像一个抽象方法都没有，但实际上并非如此。由于Link类中没有实现父类（Item）的抽象方法（makeHTML），因此它也是抽象类。

package factory;

public abstract class Link extends Item {
    protected String url;
    public Link(String caption,String url) {
        super(caption);
        this.url = url;
    }
}

抽象的零件类：Tray类

Tray类表示的是一个含有多个Link类和Tray类的容器（Tray有托盘的意思，可以想象成在托盘上放置一个个对象）。

Tray类使用add方法将Link类和Tray类集合在一起。为了表示集合的对象是“Link类和Tray类”，我们设置add方法的参数为Link类和Tray类的父类Item类。

Tray类是Item类的子类，但是没有实现抽象方法makeHTML，但它并没有实现该方法。所以Tray类也是抽象类。

package factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}

抽象的产品：Page类

Page类是抽象的表示HTML界面的类。如果将Link和Tray比喻成抽象的“零件”，那么Page类就是抽象的产品。title和author分别是表示页面标题和页面作者的字段。作者名字通过参数传给Page类的构造函数。
可以使用add方法像向页面中增加Item（即Link或者Tray）。增加的Item将会在页面中显示出来。output方法首先根据页面标题确定文件名，接着调用makeHTML方法将自身保存的HTML内容写入到文件中。

package factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected String author;
    protected ArrayList content = new ArrayList();

    public Page(String title, String author) {
        this.title=title;
        this.author = author;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename+"编写成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public abstract String makeHTML();
}

抽象的工厂：Factory类

前面我们学习了抽象零件和抽象产品的示例代码，现在终于可以来看看抽象工厂了。

package factory;

public abstract class Factory {
    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory) Class.forName(classname).newInstance();

        } catch (ClassNotFoundException e) {
            System.err.println("没有找到" + classname + "类");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }

    public abstract Link createLink(String caption, String url);
    public abstract Page createPage(String title, String author);
    public abstract Tray createTray(String caption);

}

getFactory方法可以根据指定的类名生成具体工厂的的实例。例如可以下面这样，将参数classname指定为具体工厂的类名所对应的字符串。“listFactory.ListFactory”

getFactory方法通过调用Class类的forName方法来动态地获取类信息，接着使用newInstance方法生成该类的实例，并将其作为返回值返回给调用者。

Class类属于java.lang包，是用来表示类的类。Class类包含于Java的标准类库中。forName是java.lang.Class的静态方法，newInstance则是java.lang.Class的实例方法。

请注意，虽然getFactory方法生成的是具体工厂的实例，但是返回值的类型是抽象工厂类型。
createLink、createTray、createPage等方法是用于在抽象工厂中生成零件和产品的方法。这些方法都是抽象方法，具体的实现被交给了Factory类的子类。不过这里确定了方法的名字和签名。

使用工厂将零件组装为产品：Main类

import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;

public class Main {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Usage:java Main class.name.of.ConcreteFactory");
            System.out.println("Example 1:java Main listfactory.ListFactory");
            System.out.println("Example 2:java Main tablefactory.TableFactory");
            System.exit(0);

        }

        Factory factory = Factory.getFactory(args[0]);
        Link people = factory.createLink("人民日报", "http://www.people.com.cn/");

        Link us_yahoo = factory.createLink("Yahoo!", "http://www.yahoo.com/");


        Tray traynews = factory.createTray("日报");
        traynews.add(people);

        Tray trayyahoo = factory.createTray("Yahoo!");
        trayyahoo.add(us_yahoo);

        Tray traysearch = factory.createTray("检索引擎");
        traysearch.add(trayyahoo);

        Page page = factory.createPage("LinkPage", "杨文轩");
        page.add(traynews);
        page.add(traysearch);
        page.output();
    }
}

Main类使用抽象工厂生产零件并将零件组装成产品。Main类中只引入了factory包，从这一点可以看出，该类并没有使用任何具体零件、产品、工厂。

具体工厂的类名是通过命令行来指定的。例如如果要使用listfactory包中的ListFactory类，可以在命令行中输入以下命令。
java Main listFactory.ListFactory

Main类会使用getFactory方法生成该参数(args[0])对应的工厂，并将其保存在factory变量中。之后，Main类会使用factory生成Link和Tray，然后将Link和Tray都放入Tray中，最后生成Page并将生成的结果输出至文件。

具体的工厂：ListFactory类

package listFactory;

import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;

import java.util.List;

public class ListFactory extends Factory {

    @Override
    public Link createLink(String caption, String url) {
        return new ListLink(caption,url);
    }

    @Override
    public Page createPage(String title, String author) {
        return new ListPage(title,author);
    }

    @Override
    public Tray createTray(String caption) {
        return new ListTray(caption);
    }
}

之前看的都是抽象类的代码，现在我们将视角切换到具体类。首先，我们先看看listFactory包中的工厂——ListFactory类。
ListFactory类实现了Factory类的createLink方法、createTray方法、和createPage方法。当然各个地方内部只是简单地实现new出了ListLink类的实例、ListTray类的实例以及ListPage类的实例。

具体的零件类

package listFactory;

import factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption,url);
    }

    @Override
    public String makeHTML() {
        return "<li><a href=\" "+url+"\">"+caption+"</a></li>\n";
    }
}

ListLink类是Link类的子类。在ListLink类中必须实现的方法是makeHTML抽象方法。ListLink类使用

• 标签和标签来制作HTML片段。这段HTML也可以与ListTray和ListPage的结果合并起来，就如同将螺栓和螺母拧在一起。

• 具体的零件：ListTray类

  package listFactory;
  
  import factory.Item;
  import factory.Tray;
  
  import java.util.Iterator;
  
  public class ListTray extends Tray {
      public ListTray(String caption) {
          super(caption);
      }
  
      @Override
      public String makeHTML() {
          StringBuilder buffer = new StringBuilder();
          buffer.append("<li>\n");
          buffer.append(caption + "\n");
          buffer.append("<ul>\n");
          Iterator it = tray.iterator();
          while (it.hasNext()) {
              Item item = (Item) it.next();
              buffer.append(item.makeHTML());
          }
          buffer.append("</ul>\n");
          buffer.append("</li>\n");
          return buffer.toString();
      }
  }
  
  

  具体的产品：ListPage类

  package listFactory;
  
  import factory.Item;
  import factory.Page;
  
  import java.util.Iterator;
  
  public class ListPage extends Page {
      public ListPage(String title, String author) {
          super(title,author);
      }
  
      @Override
      public String makeHTML() {
          StringBuffer buffer = new StringBuffer();
          buffer.append("<html><head><title>" + title + "</title></head>\n");
          buffer.append("<body>\n");
          buffer.append("<h1>" + title + "</h1>\n");
          buffer.append("<ul>\n");
          Iterator it = content.iterator();
          while (it.hasNext()) {
              Item item = (Item) it.next();
              buffer.append(item.makeHTML());
          }
          buffer.append("</ul>\n");
          buffer.append("<hr><address>" + author + "</address>");
          buffer.append("</body></html>\n");
          return buffer.toString();
      }
  }
  
  

  Abstract Factory模式中的登场角色

  AbstractProduct(抽象产品)

  AbstractProduct角色负责定义AbstractFactory角色所生成的抽象的零件和产品的接口（API）。在示例程序中，由Link类、Tray类和Page类扮演此角色。

  AbstractFactory(抽象工厂)

  AbstractFactory角色负责定义用于生成抽象产品的接口（API）。在本示例程序中，由Factory类扮演此角色。

  Client(委托者)

  Client角色仅会调用AbstractFactory角色和AbstractProduct角色的接口（API）来进行工作，对于具体的零件、产品和工厂一无所知。在实例程序中，由Main类扮演此角色。

  ConcreteProduct(具体产品)

  ConcreteProduct角色负责实现AbstractProduct角色的接口（API）。在实例程序中，由以下包中的以下类扮演此角色。
  listFactory包：ListFactory