• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

ASP.NET AJAX(6)__Microsoft AJAX Library中的面向对象类型系统

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

如果我们可以合理的使用面向对象编程,我们可以提高代码的复用性和可维护性,这里强调的是合理的使用,有了面向对象类型系统,就可以使用一些成熟的设计方式

命名空间

  • 合理的组织大量的类型,使开发人员能够方便的找到他们所需要的类型
  • 可重复注册命名空间,每个独立的脚本模块前都要注册命名空间以保证命名空间存在

  • 定义构造函数
  • 定义成员(方法、属性、事件)
  • 注册类

类——构造函数

  • 类的构造函数即为function定义
  • 通常用于初始化域变量
  • 自由成员使用下划线开头(形式上的封装)

类——定义方法

  • 使用prototype定义
  • MyNamespace.MyClass.prototype={method1:function{},method2:function()}

类——定义属性

  • Microsoft AJAX Library的面向对象类型系统将get_xxx和set_xxx开头的方法认做属性(一种约定)
  • 避免定义只写属性,使用某个方法替代

类——注册类

  1. Tye.registerNamespace("MyNamespace");
  2. MyNamespace.MyClass=function(parm1,…){…}
  3. MyNamespace.MyClass.prototype={…}
  4. MyNamespace.MyClass.registerClass("MyNamespace.MyClass");
一个定义以及使用类的示例

创建一个js文件

我们可以在js文件一开始,写上/// <reference name="MicrosoftAjax.js" />这样一段代码,就可以在VS里得到很多关于Microsoft AJAX Library的代码提示

/// <reference name="MicrosoftAjax.js" />

Type.registerNamespace("MyNamespace");//注册一个命名空间
MyNamespace.Employee = function(name) {//定义一个构造函数
    this._name = name ? name : "Anonymous";//初始化域变量
    this._year = 0; //初始化域变量
}

MyNamespace.Employee.prototype =//定义类成员
{
    get_name: function() {//定义属性
        return this._name;
    },//注意都是用逗号分割的
    get_year: function() {//定义属性
        return this._year;
    },
    set_year: function(value) {//定义属性
        this._year = value;
    },

    calculateSalary: function() {//定义一个方法
        return this._year * 1000;
       // throw Error.notImplemented();
    },

    getDescription: function() {//定义一个方法
        return String.format("{0} gets {1} yuan per month", this._name, this.calculateSalary());
    }
}
MyNamespace.Employee.registerClass("MyNamespace.Employee"); //注册类
 

这样,我们就定义了一个简单的Employee类

创建一个aspx页面,并使用我们定义好的Employee类

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:ScriptManager ID="s" runat="server">
            <Scripts>
                <asp:ScriptReference Path="~/Demo05/Employee.js" />
            </Scripts>
        </asp:ScriptManager>
        <div id="info">
        </div>

        <script language="javascript" type="text/javascript">
               function display(text) {
                   document.getElementById("info").innerHTML+=text+"<br/>";
               }

               var xiaoyaojian = new MyNamespace.Employee("xiaoyaojian");
               xiaoyaojian.set_year(4);
               display(xiaoyaojian.getDescription());
        </script>
    </form>   
</body>
</html>

 

调试,出结果,用法很简单,和c#类相同

 

类——抽象类

  • 包含抽象方法的类即为抽象类
  • MyNamespace.MyClass.prototype{this._mymethod=function{throw Error.notImplemented();}}//包含抽象方法

类——继承

  • 调用父类的构造函数
  • 有父类的类必须调用父类的构造函数,否则会丢失继承效果(不和c#相同,c#自动调用)
  • MyNamespace.MyClass=function(){MyNamespace.MyClass.initializeBase(this,[param1,…])}
  • 注册时候提供父类
  • 可以直接以普通方式实现父类的抽象成员
  • toString方法无法被继承

类——调用父类方法

  • MyNamespace.MyClass.prototype={myMethod:function(param1,…){MyNamesapce.MyClass.callBaseMethod(this,"meMethod",[param1,…])}}
一个示例

修改上面的Employee.js

 

/// <reference name="MicrosoftAjax.js" />

Type.registerNamespace("MyNamespace");//注册一个命名空间

MyNamespace.Employee = function(name) {//定义一个构造函数
    this._name = name ? name : "Anonymous";//初始化域变量
    this._year = 0; //初始化域变量
}

MyNamespace.Employee.prototype =//定义类成员
{
    get_name: function() {//定义属性
        return this._name;
    },//注意都是用逗号分割的
    get_year: function() {//定义属性
        return this._year;
    },
    set_year: function(value) {//定义属性
        this._year = value;
    },

    calculateSalary: function() {//定义一个方法
        //return this._year * 1000;
        throw Error.notImplemented();//抛出异常,这个方法是抽象方法,说明这个类是抽象类
    },

    getDescription: function() {//定义一个方法
        return String.format("{0} gets {1} yuan per month", this._name, this.calculateSalary());
    }
}
MyNamespace.Employee.registerClass("MyNamespace.Employee"); //注册类
//MyNamespace.Employee.registerClass("MyNamespace.Employee", null, MyNamespace.IEmployee);//注册类


MyNamespace.Intern = function(name) {
    MyNamespace.Intern.initializeBase(this, [name]);//调用父类构造函数
}

MyNamespace.Intern.prototype =
{
    calculateSalary: function() {
        return 2000;

    },
    getDescription: function() {
        var description = MyNamespace.Intern.callBaseMethod(this, "getDescription");//调用父类方法
           
        return description + ",What a poor intern!";

    }
}

MyNamespace.Intern.registerClass("MyNamespace.Intern", MyNamespace.Employee); //注册这个类,继承MyNamespace.Employee


MyNamespace.Vendor = function(name) {
    MyNamespace.Vendor.initializeBase(this, [name]);
}

MyNamespace.Vendor.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 5000 + 1000 * (this.get_year() - 1);
    }
}

MyNamespace.Vendor.registerClass("MyNamespace.Vendor", MyNamespace.Employee);


MyNamespace.FulltimeEmployee = function(name) {
    MyNamespace.FulltimeEmployee.initializeBase(this, [name]);
}

MyNamespace.FulltimeEmployee.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 15000 + 2000 * (this.get_year());
    }
}

MyNamespace.FulltimeEmployee.registerClass("MyNamespace.FulltimeEmployee", MyNamespace.Employee);

 

这时,我们再打开刚才的页面,就会出现一个方法未实现错误,因为我们实例化一个抽象类,这不符合逻辑

 

修改页面代码

<script language="javascript" type="text/javascript">
               function display(text) {
                   document.getElementById("info").innerHTML+=text+"<br/>";
               }

               var xiaoyaojian = new MyNamespace.Intern("Xiaoyaojian");
               xiaoyaojian.set_year(3);
               display(xiaoyaojian.getDescription());

               var xiaobai = new MyNamespace.Vendor("Xiaobai");
               xiaobai.set_year(3);
               display(xiaobai.getDescription());

               var xiaobaigege = new MyNamespace.FulltimeEmployee("Xiaobaigege");
               xiaobaigege.set_year(5);
               display(xiaobaigege.getDescription());
        </script>

 

这样,成功的使用了我们创建了继承Employee的三个类

 

接口

  • 与类的定义方法大致相同
  • 构造函数抛出异常
  • 所有的方法抛出异常(只有方法签名,不提供实现)
  • 注册接口时使用registerInterface方法
  • 接口无法继承其他接口

接口定义

  • MyNamespace.IMyInterface=function(){throw Error.notImplemented()}
  • MyNamespace.IMyInterface.prototype={myMethod:function(){throw Error.notImplemented()}}
  • MyNamespace.IMyInterface.registerInterface(“MyNamespace.IMyInterface”);

接口实现

  • 在使用registerClass方法注册类时候可以传入额外的参数来实现接口
  • MyNamespace.MyClass.registerClass("MyNamespace.IMyInterface",null,IMyInterface1,IMyInterface1,…);
一个关于接口的示例

同样,还是修改Employee.js文件

/// <reference name="MicrosoftAjax.js" />

Type.registerNamespace("MyNamespace"); //注册一个命名空间

MyNamespace.IEmployee = function() {
    throw Error.notImplemented();
}
MyNamespace.IEmployee.prototype = {
    calcaulateSalary: function() {
        throw Error.notImplemented();
    }
}
MyNamespace.IEmployee.registerInterface("MyNamespace.IEmployee");


MyNamespace.Employee = function(name) {//定义一个构造函数
    this._name = name ? name : "Anonymous";//初始化域变量
    this._year = 0; //初始化域变量
}

MyNamespace.Employee.prototype =//定义类成员
{
    get_name: function() {//定义属性
        return this._name;
    },//注意都是用逗号分割的
    get_year: function() {//定义属性
        return this._year;
    },
    set_year: function(value) {//定义属性
        this._year = value;
    },

    calculateSalary: function() {//定义一个方法
        //return this._year * 1000;
        throw Error.notImplemented();//抛出异常,这个方法是抽象方法,说明这个类是抽象类
    },

    getDescription: function() {//定义一个方法
        return String.format("{0} gets {1} yuan per month", this._name, this.calculateSalary());
    }
}
//MyNamespace.Employee.registerClass("MyNamespace.Employee"); //注册类
MyNamespace.Employee.registerClass("MyNamespace.Employee", null, MyNamespace.IEmployee);//注册类


MyNamespace.Intern = function(name) {
    MyNamespace.Intern.initializeBase(this, [name]);//调用父类构造函数
}

MyNamespace.Intern.prototype =
{
    calculateSalary: function() {
        return 2000;

    },
    getDescription: function() {
        var description = MyNamespace.Intern.callBaseMethod(this, "getDescription");
        return description + ",What a poor intern!";

    }
}

MyNamespace.Intern.registerClass("MyNamespace.Intern", MyNamespace.Employee); //注册这个类,继承MyNamespace.Employee


MyNamespace.Vendor = function(name) {
    MyNamespace.Vendor.initializeBase(this, [name]);
}

MyNamespace.Vendor.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 5000 + 1000 * (this.get_year() - 1);
    }
}

MyNamespace.Vendor.registerClass("MyNamespace.Vendor", MyNamespace.Employee);


MyNamespace.FulltimeEmployee = function(name) {
    MyNamespace.FulltimeEmployee.initializeBase(this, [name]);
}

MyNamespace.FulltimeEmployee.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 15000 + 2000 * (this.get_year());
    }
}

MyNamespace.FulltimeEmployee.registerClass("MyNamespace.FulltimeEmployee", MyNamespace.Employee);
 
 

这时,在页面中还使用这些类还是没有问题的,如果我们要体现这个接口的继承,可以在页面<script>中添加如下代码

display("Xiaoyaojian implements 'IEmployee' interface:" + MyNamespace.IEmployee.isImplementedBy(xiaoyaojian))

 

za在页面中,我们可以看到返回的结果是true,说明Employee实现了接口IEmployee

 

 

枚举

  • 枚举即为Number
  • 增加可读性
  • 可以定义为标记
  • 每个枚举类型均有toString和parse方法

枚举的定义

MyNamespace.MyEnum=function(){throw Error.notImplemented();}
MyNamespace.MyEnum.prototoype={item1:1,item2:2,item3:4}
MyNamespace.MyEnum.registerEnum(“MyNamespace.MyEnum”,[true])//true表示是否定义一个标记

 

一个定义以及使用枚举的示例

修改Employee.js

/// <reference name="MicrosoftAjax.js" />

Type.registerNamespace("MyNamespace"); //注册一个命名空间

MyNamespace.EmployeeType = function() {
    throw Error.notImplemented();//抛出异常,无法实例化
}
MyNamespace.EmployeeType.prototype =//定义成员
{
    Intern: 0,
    Vendor: 1,
    FulltiomEmployee: 2
}
MyNamespace.EmployeeType.registerEnum("MyNamespace.EmployeeType");//注册枚举

MyNamespace.IEmployee = function() {
    throw Error.notImplemented();
}
MyNamespace.IEmployee.prototype = {
    calcaulateSalary: function() {
        throw Error.notImplemented();
    },
    get_type: function() {
        throw Error.notImplemented();
    }
}
MyNamespace.IEmployee.registerInterface("MyNamespace.IEmployee");


MyNamespace.Employee = function(name) {//定义一个构造函数
    this._name = name ? name : "Anonymous";//初始化域变量
    this._year = 0; //初始化域变量
}

MyNamespace.Employee.prototype =//定义类成员
{
    get_name: function() {//定义属性
        return this._name;
    },//注意都是用逗号分割的
    get_year: function() {//定义属性
        return this._year;
    },
    set_year: function(value) {//定义属性
        this._year = value;
    },

    calculateSalary: function() {//定义一个方法
        //return this._year * 1000;
        throw Error.notImplemented();//抛出异常,这个方法是抽象方法,说明这个类是抽象类
    },

    getDescription: function() {//定义一个方法
        return String.format("{0} gets {1} yuan per month", this._name, this.calculateSalary());
    }
}
//MyNamespace.Employee.registerClass("MyNamespace.Employee"); //注册类
MyNamespace.Employee.registerClass("MyNamespace.Employee", null, MyNamespace.IEmployee);//注册类


MyNamespace.Intern = function(name) {
    MyNamespace.Intern.initializeBase(this, [name]);//调用父类构造函数
}

MyNamespace.Intern.prototype =
{
    calculateSalary: function() {
        return 2000;

    },
    getDescription: function() {
        var description = MyNamespace.Intern.callBaseMethod(this, "getDescription");
        return description + ",What a poor intern!";

    },
    get_type: function() {
        return MyNamespace.EmployeeType.Intern;
    }
}

MyNamespace.Intern.registerClass("MyNamespace.Intern", MyNamespace.Employee); //注册这个类,继承MyNamespace.Employee


MyNamespace.Vendor = function(name) {
    MyNamespace.Vendor.initializeBase(this, [name]);
}

MyNamespace.Vendor.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 5000 + 1000 * (this.get_year() - 1);
    },
    get_type: function() {
        return MyNamespace.EmployeeType.Vendor;
    }
}

MyNamespace.Vendor.registerClass("MyNamespace.Vendor", MyNamespace.Employee);


MyNamespace.FulltimeEmployee = function(name) {
    MyNamespace.FulltimeEmployee.initializeBase(this, [name]);
}

MyNamespace.FulltimeEmployee.prototype =
{
    calculateSalary: function() {
        //return 2000;
        return 15000 + 2000 * (this.get_year());
    },
    get_type: function() {
        return MyNamespace.EmployeeType.FulltimeEmployee;
    }
}

MyNamespace.FulltimeEmployee.registerClass("MyNamespace.FulltimeEmployee", MyNamespace.Employee);

 

这时,在页面中<script>中添加如下代码

 

var type = MyNamespace.EmployeeType.toString(xiaoyaojian.get_type());
               display(String.format("{0} is a {1}", xiaoyaojian.get_name(), type));

 

刷新页面,出现效果,如果我们不使用MyNamespace.EmployeeType.toString(),这里就会出现一个“1”,符合我们的定义

 

定义个作为标记的枚举类

在Employee.js里添加如下内容

MyNamespace.MyFlags = function() {
    throw Error.notImplemented();
}
MyNamespace.MyFlags.prototype =
{
    Item1:1,
    Item2:2,
    Item3:4,
    None:0,
    All:7
}
MyNamespace.MyFlags.registerEnum("MyNamespace.MyFlags",true);

 

在页面中我们可以这样使用

 

var all = MyNamespace.MyFlags.All;
               display(all);
               display(MyNamespace.MyFlags.toString(all));

               display(MyNamespace.MyFlags.parse("Item1,Item3")); //"Item1,Item3"这是一个标准的表示方法,结果为Item1+Item3的结果

 

反射方法

  • Type.prototype.getBaseType//得到父类
  • Type.prototype.getInterfaces//得到实现的接口
  • Type.prototype.getName//得到类名
  • Type.prototype.implementsInterface//得到是否实现某接口
  • Type.prototype.inheritsFrom//确定一个类型是否从特定的基类型继承
  • Type.prototype.isImplementedBy//确定实例是否实现了特定接口
  • Type.getRootNamespaces//返回一个数组,包含对客户端应用程序的所有根命名空间的引用
  • Type.prototype.isInstanceOfType//如果当前 Type 在 object 表示的对象的继承层次结构中,或者如果当前 Type 是 object 支持的接口,则为 true
  • Type.isClass
  • Type.isInterface
  • Type.isNamespace
  • Type.isEnum
  • Type.isFlags
  • Type.parse

后面这几个,我就不多做解释啦

 

到此讲完

今天是小白的生日,纪念一下


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
ASP.NET Core 之 Identity 入门(一)发布时间:2022-07-10
下一篇:
ASP.NET Core中获取完整的URL(转载)发布时间:2022-07-10
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap