js39---组合模式,查找遍历树

/**
 *有这样一个需求
 *有一个学校有2个班(一班,二班)
 *每个班级分2个小组(一班一组,一班二组,二班一组,二班二组)
 *学校计算机教室有限,每一个小组分着来上课.
 *考试的时候大家一起考
 *请用程序来模拟这个需求
 */
(function(){
    //不用组合模式
    //学校类
    var school = function(name){
        this.name = name;
        //班级
        var classes = new Array();
        this.addClasses = function(cla){
            classes.push(cla);
            return this;
        }
        this.getClasses = function(){
            return classes;
        }
    }
    //班级类
    var classes = function(name){
        this.name = name;
        var groups = new Array();
        this.getGroup = function(){
            return groups;
        }
        this.addGroup = function(group){
            groups.push(group);
            return this;
        }
    }
    //组
    var group  = function(name){
        this.name = name;
        var students = new Array();
        this.getStudent = function(){
            return students;
        }
        this.addStudent = function(stu){
            students.push(stu);
            return this;
        }
    }
    //学生类
    var student  = function(name){
        this.name = name;
        this.goToClass = function(){
            document.write(this.name+" 去上课");
        }
        this.finishClass = function(){
            document.write(this.name+" 下课");
        }
    }

    //测试
    var a = new student("a");
    var b = new student("b");
    var c = new student("c");
    var d = new student("d");
    var e = new student("e");
    var f = new student("f");
    var g = new student("g");
    var h = new student("h");
    var i = new student("i");
    var one = new classes("一班");
        var oneOne = new group("一班一组");
            oneOne.addStudent(a).addStudent(b);
        var oneTwo = new group("一班二组");
            oneTwo.addStudent(c).addStudent(d);

        one.addGroup(oneOne).addGroup(oneTwo);
    var two = new classes("二班");
        var twoOne = new group("二班一组");
            twoOne.addStudent(e).addStudent(f);
        var twoTwo = new group("二班二组");
            twoTwo.addStudent(g).addStudent(h).addStudent(i)
        two.addGroup(twoOne).addGroup(twoTwo);
    var usPcat = new school("波斯卡特计算机培训学校");
    usPcat.addClasses(one).addClasses(two);

    //调用  就写一个 一班一组去上课
    var classes= usPcat.getClasses();
    for (var i = 0; i < classes.length; i++) {
        if(classes[i].name == "一班"){
            for (var j = 0; j < classes[i].getGroup().length; j++) {
//                document.write(classes[i].getGroup()[j])
                if(classes[i].getGroup()[j].name == "一班一组"){
                    var s = classes[i].getGroup()[j].getStudent();
                    for (var k = 0; k < s.length; k++) {
                        s[k].goToClass();
                    }
                }
            }

        }
    }
    //我快些吐了
    //这种方法一定不是和业务的扩展
})()
/**
 * 组合模式
 */
(function(){
    //统一接口
    var composite = new Interface("composite",["getChildByName","add"]);
    var student= new Interface("composite",["goToClass","finishClass"]);

    //定义组合类
    var compositeObj = function(name){
        this.name = name;
        this.type = "com";//默认是组合类
        var childs = new Array();
        //得到相关的所有孩子节点
        this.getChildByName = function(name){
            //涉及到递归
            var toChilds = new Array();
            if(!name){//没有传名字,左根遍历树
                for (var i = 0; i < childs.length; i++) {
                    if(childs[i].type == "com"){
                        toChilds = toChilds.concat(childs[i].getChildByName());
                    }else{
                        toChilds.push(childs[i]);
                    }
                }
            }else{//左先根查找树
                for (var i = 0; i < childs.length; i++) {
                    if(childs[i].name == name){
                        if(childs[i].type == "com"){
                            toChilds =     toChilds.concat(childs[i].getChildByName());
                            break;
                        }else{
                            toChilds.push(childs[i]);
                            break;
                        }
                    }else{
                        if(childs[i].type == "com"){
                            toChilds =     toChilds.concat(childs[i].getChildByName(name));
                        }
                    }
                }
            }
            return toChilds;
        }
        //增加子节点
        this.add = function(child){
            childs.push(child);
            return this;
        }
        //去上课
        this.goToClass = function(name){
            var toChilds = this.getChildByName(name);
            for (var i = 0; i < toChilds.length; i++) {
                toChilds[i].goToClass();
            }
        }
        //下课
        this.finishClass = function(name){
            var toChilds = this.getChildByName(name);
            for (var i = 0; i < toChilds.length; i++) {
                toChilds[i].finishClass();
            }
        }
        Interface.ensureImplements(this,composite,student)
    }

    //定义叶子类
    var studentObj = function(name){
        this.name = name;
        this.type = "stu";//默认是叶子
        //得到相关的所有孩子节点
        this.getChildByName = function(name){
            if(this.name == name){
                return this;
            }else{
                return null;
            }
        }
        //增加子节点
        this.add = function(child){
            throw new Error("add 不成被初始化(在叶子了中)");
        }
        //去上课
        this.goToClass = function(name){
            document.write(this.name +" 去上课<br>");
        }
        //下课
        this.finishClass = function(name){
            document.write(this.name +" 下课<br>");
        }
        Interface.ensureImplements(this,composite,student)
    }

    //测试
    var a = new studentObj("a");
    var b = new studentObj("b");
    var c = new studentObj("c");
    var d = new studentObj("d");
    var e = new studentObj("e");
    var f = new studentObj("f");
    var g = new studentObj("g");
    var h = new studentObj("h");
    var i = new studentObj("i");
    var one = new compositeObj("一班");
        var oneOne = new compositeObj("一班一组");
            oneOne.add(a).add(b);
        var oneTwo = new compositeObj("一班二组");
            oneTwo.add(c).add(d);

        one.add(oneOne).add(oneTwo);
    var two = new compositeObj("二班");
        var twoOne = new compositeObj("二班一组");
            twoOne.add(e).add(f);
        var twoTwo = new compositeObj("二班二组");
            twoTwo.add(g).add(h).add(i)
        two.add(twoOne).add(twoTwo);
    var usPcat = new compositeObj("波斯卡特计算机培训学校");
    usPcat.add(one).add(two);
    //客户端调用API
    usPcat.goToClass();
    document.write("-------------------------<br>");
    usPcat.goToClass("一班");
    document.write("-------------------------<br>");
    usPcat.goToClass("二班一组");
    document.write("-------------------------<br>");
    usPcat.goToClass("a");
})()
时间: 2024-12-09 20:17:08

js39---组合模式,查找遍历树的相关文章

组合模式(遍历树)

组合模式多个对象形成树形结构以表示"整体--部分"的结构层次.组合模式对单个对象(即叶子对象)和组合对象(即容器对象)的使用具有一致性. 组合模式又可以称为"合成模式" 或 "整体-部分模式",属于对象的结构型模式,它将对象组织到树形结构中,可以用来描述整体与部分的关系. 容器与叶子节点来自于同一个·接口,省去类型转化的麻烦. 在设计中将容器和叶子节点进行递归组合,使得用户在使用时无需对他们进行区分,可以一致的对待容器对象和叶子对象,叶子对象是没

组合模式的详解

在Word文档中,我们经常会对一个字或者一段话进行设定它的大小.字体等属性:但很少停下来站在程序的角度,想想它是怎么样的原理?今天,我们就对此进行一个讲解.微软在设计的时候,应该是这样的:它把一个段话看成一个整体,而把单个字看成一个单独的部分:整体与部分之间的所有操作都是一样的,并用同一的方式进行调用(也就是说都是从同一个基类继承出来的).在设计模式当中,我们把它叫组合模式. 如何定义?将对象组合成树形结构以表示"部分---整体"的层次结构.这种模式使得用户对单个对象和组合对象的使用具

优雅的处理树状结构——组合模式总结

1.前言 本模式经 遍历“容器”的优雅方法——总结迭代器模式 引出,继续看最后的子菜单的案例 2.组合模式的概念 组合模式,也叫 Composite 模式……是构造型的设计模式之一. 组合模式允许对象组合成树形结构,来表现“整体/部分”的层次结构,使得客户端对单个对象和组合对象的使用具有一致性. Composite Pattern Compose objects into tree structures to represent part-whole hierarchies. Composite

设计模式组合模式(Composite)精华

23种子GOF设计模式一般分为三类:创建模式.结构模型.行为模式. 创建模式抽象的实例,他们帮助如何创建一个系统独立.这是一个这些对象和陈述的组合. 创建使用继承类的类架构更改实例.的对象类型模型的建立也将委托实例化一个对象. 创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些详细的类的信息封装起来.第二,它们隐藏了这些类的实例是怎样被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此.创建型模式在什么被创建.谁创建它,它是怎样被创建的,以及何时创建这些方

设计模式之组合模式(Composite)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

第 15 章 组合模式【Composite Pattern】

以下内容出自:<<24种设计模式介绍与6大设计原则>> 大家在上学的时候应该都学过“数据结构”这门课程吧,还记得其中有一节叫“二叉树”吧,我们上 学那会儿这一章节是必考内容,左子树,右子树,什么先序遍历后序遍历什么,重点就是二叉树的的遍历,我还记得当时老师就说,考试的时候一定有二叉树的构建和遍历,现在想起来还是觉的老师是正确的,树状结果在实际项目应用的非常广泛. 咱就先说个最常见的例子,公司的人事管理就是一个典型的树状结构,你想想你公司的结构是不是这样: 老大,往下一层一层的管理,

24种设计模式--组合模式【Composite Pattern】

大家在上学的时候应该都学过“数据结构”这门课程吧,还记得其中有一节叫“二叉树”吧,我们上学那会儿这一章节是必考内容,左子树,右子树,什么先序遍历后序遍历什么,重点就是二叉树的的遍历,我还记得当时老师就说,考试的时候一定有二叉树的构建和遍历,现在想起来还是觉的老师是正确的,树状结果在实际项目应用的非常广泛. 咱就先说个最常见的例子,公司的人事管理就是一个典型的树状结构,你想想你公司的结构是不是这样: 从最高的老大,往下一层一层的管理,最后到我们这层小兵,很典型的树状结构(说明一下,这不是二叉树,有

java设计模式之组合模式

树形结构在软件中随处可见,例如操作系统中的目录结构.应用软件中的菜单.办公系统中的公司组织结构等等,如何运用面向对象的方式来处理这种树形结构是组合模式需要解决的问题,组合模式通过一种巧妙的设计方案使得用户可以一致性地处理整个树形结构或者树形结构的一部分,也可以一致性地处理树形结构中的叶子节点(不包含子节点的节点)和容器节点(包含子节点的节点).下面将学习这种用于处理树形结构的组合模式. 11.1 设计杀毒软件的框架结构 Sunny软件公司欲开发一个杀毒(AntiVirus)软件,该软件既可以对某

.NET设计模式(11):组合模式(Composite Pattern)(转)

概述 组合模式有时候又叫做部分-整体模式,它使我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦. 意图 将对象组合成树形结构以表示“部分-整体”的层次结构.Composite模式使得用户对单个对象和组合对象的使用具有一致性.[GOF <设计模式>] 结构图 图1 Composite模式结构图 生活中的例子 组合模式将对象组合成树形结构以表示"部分-整体"的层次结构.让用户一致地使用单