◎ 節(jié)點類的設(shè)計
   ·特征分析
       數(shù)據(jù)特征：名字、節(jié)點值、節(jié)點的屬性、節(jié)點的父節(jié)點、節(jié)點下的子節(jié)點、參照對象等特點
       行為特征：得到節(jié)點名、節(jié)點值、子節(jié)點、節(jié)點的屬性、參照對象
                 增加子節(jié)點、屬性、參照對象
                 刪除子節(jié)點、屬性
                 設(shè)置父節(jié)點
                 判斷節(jié)點是否為空（沒有值且沒有子節(jié)點和屬性）
                 遍歷節(jié)點及節(jié)點下的所有子節(jié)點（以及子節(jié)點下的子節(jié)點）
                 對于像子節(jié)點、屬性這類可以有多個對象的數(shù)據(jù)，應(yīng)提供
                     根據(jù)名字獲取節(jié)點集合的操作；獲取所有節(jié)點集合的操作；獲取某位置的節(jié)點；遍歷所有節(jié)點；獲取集合數(shù)量
             另外，子節(jié)點和節(jié)點具有共同的特征，只是子節(jié)點是節(jié)點的集合，如上所述，同時子節(jié)點有一些集合所特有的操作；
             屬性則是節(jié)點的一個子集，具有名字、值、父節(jié)點，可以當(dāng)作節(jié)點來處理。
   ·類設(shè)計
      節(jié)點類Node
     子節(jié)點類SubNodes
     另外為了在遍歷過程中，可以針對所遍歷的每個節(jié)點執(zhí)行自定義的動作，提供NodeVisit接口
      同時提供NodeVisit接口的適配NodeVisitAdaptor
   ·遍歷的問題
     首先執(zhí)行節(jié)點的訪問Node.visit，然后在Node.visit方法中調(diào)用子節(jié)點SubNodes.visit方法，在SubNodes.visit方法中對集合中的
     所有節(jié)點（Node），調(diào)用Node.visit，這樣就實現(xiàn)了給定節(jié)點及該節(jié)點下面所有節(jié)點的遍歷。
     原理：實際上是一種互調(diào)。即在A類對象中調(diào)用B類對象的方法，同時又在B類對象的同一個方法中調(diào)用A類對象的方法。
           A類和B類的約束，A類包含一個B類對象，B類包含了A類對象的集合，A類對象和B類對象擁有同樣的調(diào)用方法visit（也可以是其它名字）。
           這樣當(dāng)A調(diào)用B的方法時，B遍歷所有的A并調(diào)用A的方法，由此實現(xiàn)了遍歷訪問。
           最后，請記住遍歷的對象應(yīng)該是相同的類對象。
   ·框架
     public class Node{
        private String ms_Name;

        private Object mo_Value;

        private SubNodes msn_Children;

        private SubNodes msn_Attributes;

        public String getName();

        public Object getValue();

        public void setParentNode(Node);

        public void addChild(Node);

        public int getChildrenCount();

        public int getChildrenCount(String childName)

        public List getChildren();

        public List getChildren(String childName);

        public Node getChild(int index);

        public boolean removeChild(Node);

        public boolean removeChildren(String childName);

        public boolean removeChildren();

        public void addAttribute(Node);

        public int getAttributeCount();

        public int getAttributeCount(String attrName)

        public List getAttributes();

        public List getAttributes(String attrName);

        public Node getAttribute(int index);

        public boolean removeAttribute(Node);

        public boolean removeAttributes(String attrName);

        public boolean removeAttributes();

        public boolean isAttribute();//檢查節(jié)點是否是一個屬性節(jié)點

        public boolean isDefined();//節(jié)點是否定義過，即節(jié)點有值或有子節(jié)點

        public void visit(NodeVisit);

        protected static class SubNodes{

            private List ml_nodes;//子節(jié)點

            private Map mm_namedNodes;//子節(jié)點名字與子節(jié)點鏈表的映射，即多個子節(jié)點可以有相同的名字

            public void addNode(Node);

            public boolean removeNode(Node);

            public boolean removeNodes(String);

            public void clear();

            public ConfigurationNode getNode(int index);

            public List getSubNodes();//返回所有子節(jié)點

            public List getSubNodes(String name);

            public void visit(NodeVisit)

        }

     }
     public interface NodeVisitor{
         void visitBeforeChildren(ConfigurationNode node);//在該節(jié)點的所有子節(jié)點被處理之前，訪問該節(jié)點
         void visitAfterChildren(ConfigurationNode node);//在該節(jié)點的所有子節(jié)點被處理之后，訪問該節(jié)點
         boolean terminate();//結(jié)束標識，通知訪問方法是否結(jié)束。通過該標識，可以實現(xiàn)某種搜索策略。
     }
   ·Jarkarta開源的實現(xiàn)片段
     public class DefaultConfigurationNode implements ConfigurationNode, Cloneable{
         public void addChild(ConfigurationNode child)//增加子節(jié)點
         {
             children.addNode(child);
             child.setAttribute(false);
             child.setParentNode(this);//設(shè)置父節(jié)點
         }
         public void addAttribute(ConfigurationNode attr){//增加屬性
             attributes.addNode(attr);
             attr.setAttribute(true);
             attr.setParentNode(this);
         }
         public boolean isAttribute(){//節(jié)點是否是屬性節(jié)點
             return attribute;
         }
         public void setAttribute(boolean f){//設(shè)置節(jié)點是否是屬性節(jié)點
             checkState();
             attribute = f;
         }
         public boolean isDefined(){//節(jié)點是否已經(jīng)定義
             return getValue() != null || getChildrenCount() > 0
                     || getAttributeCount() > 0;
         }
         public void visit(ConfigurationNodeVisitor visitor){//遍歷節(jié)點
             if (visitor == null){
                 throw new IllegalArgumentException("Visitor must not be null!");
             }
             if (!visitor.terminate()){
                 visitor.visitBeforeChildren(this);//執(zhí)行自定義訪問動作
                 children.visit(visitor);//調(diào)用子節(jié)點的visit，從而實現(xiàn)了該節(jié)點下面所有節(jié)點的遍歷
                 attributes.visit(visitor);
                 visitor.visitAfterChildren(this);//執(zhí)行自定義訪問動作
             }
         }
         public Object clone(){//淺克隆，因為克隆后子節(jié)點和屬性都進行了初始化
             try{
                 DefaultConfigurationNode copy = (DefaultConfigurationNode) super
                         .clone();
                 copy.initSubNodes();
                 return copy;
             }catch (CloneNotSupportedException cex){
                 return null; // should not happen
             }
         }
         protected void checkState(){
             if (getParentNode() != null){
                 throw new IllegalStateException(
                         "Node cannot be modified when added to a parent!");
             }
         }
         protected SubNodes createSubNodes(boolean attributes){//創(chuàng)建子節(jié)點
             return new SubNodes();
         }
         private void initSubNodes(){//初始化子節(jié)點和屬性
             children = createSubNodes(false);
             attributes = createSubNodes(true);
         }
         protected static class SubNodes{//內(nèi)部類，幫助DefaultConfigurationNode管理子節(jié)點
             private List nodes;
             private Map namedNodes;
             public void addNode(ConfigurationNode node){//增加一個子節(jié)點
                 if (node == null || node.getName() == null){
                     throw new IllegalArgumentException(
                             "Node to add must have a defined name!");
                 }
                 node.setParentNode(null);  //設(shè)置為空，由DefaultConfigurationNode的addChild來完成setParent
                 if (nodes == null){
                     nodes = new ArrayList();
                     namedNodes = new HashMap();
                 }
                 nodes.add(node);
                 List lst = (List) namedNodes.get(node.getName());
                 if (lst == null){
                     lst = new LinkedList();//鏈表結(jié)構(gòu)
                     namedNodes.put(node.getName(), lst);
                 }
                 lst.add(node);
             }
             public boolean removeNode(ConfigurationNode node){//刪除一個子節(jié)點
                 if (nodes != null && node != null && nodes.contains(node)){
                     detachNode(node);
                     nodes.remove(node);
                     List lst = (List) namedNodes.get(node.getName());
                     if (lst != null){
                         lst.remove(node);
                         if (lst.isEmpty()){
                             namedNodes.remove(node.getName());
                         }
                     }
                     return true;
                 }else{
                     return false;
                 }
             }
             public boolean removeNodes(String name){//清除所有名字為name的子節(jié)點
                 if (nodes != null && name != null){
                     List lst = (List) namedNodes.remove(name);
                     if (lst != null){
                         detachNodes(lst);
                         nodes.removeAll(lst);
                         return true;
                     }
                 }
                 return false;
             }
             public void clear(){//清除所有子節(jié)點
                 if (nodes != null){
                     detachNodes(nodes);
                     nodes = null;
                     namedNodes = null;
                 }
             }
             public ConfigurationNode getNode(int index){//取第index個子節(jié)點index從0開始
                 if (nodes == null)
                 {
                     throw new IndexOutOfBoundsException("No sub nodes available!");
                 }
                 return (ConfigurationNode) nodes.get(index);
             }
             public List getSubNodes(){//取所有子節(jié)點
                 return (nodes == null) ? Collections.EMPTY_LIST : Collections
                         .unmodifiableList(nodes);
             }
             public List getSubNodes(String name){//取所有名字為name的子節(jié)點
                 if (name == null){//如果name為空返回所有子節(jié)點
                     return getSubNodes();
                 }
                 List result;
                 if (nodes == null){
                     result = null;
                 }else{
                     result = (List) namedNodes.get(name);
                 }
                 return (result == null) ? Collections.EMPTY_LIST : Collections
                         .unmodifiableList(result);
             }
             public void visit(ConfigurationNodeVisitor visitor){//遍歷所有子節(jié)點
                 if (nodes != null)
                 {
                     for (Iterator it = nodes.iterator(); it.hasNext()
                             && !visitor.terminate();)
                     {
                         ((ConfigurationNode) it.next()).visit(visitor);//通過與Node的配合實現(xiàn)了遍歷功能
                     }
                 }
             }
             //刪除一個子節(jié)點時調(diào)用此方法，確保被刪除節(jié)點的父對象被置空（reset），同時清除被刪除節(jié)點所有的引用
             protected void detachNode(ConfigurationNode subNode){
                 subNode.setParentNode(null);
                 if (subNode instanceof DefaultConfigurationNode){
                     ((DefaultConfigurationNode) subNode).removeReference();
                 }
             }
             protected void detachNodes(Collection subNodes){
                 for (Iterator it = subNodes.iterator(); it.hasNext();){
                     detachNode((ConfigurationNode) it.next());
                 }
             }
         }
     }
   ·遍歷調(diào)用的例子
     protected static void clearReferences(ConfigurationNode node){//清除所有的引用
         node.visit(new ConfigurationNodeVisitorAdapter(){//匿名實現(xiàn)
             public void visitBeforeChildren(ConfigurationNode nodeClearRef){
                 nodeClearRef.setReference(null);
             }
         });
     }