ASP.NET AJAX(6)__Microsoft AJAX Library中的面向对象类型系统命名空间类类——构造函数类——定义方法类——定义属性类——注册类类——抽象类类——继承类——调用父类方

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

命名空间

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

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

类——构造函数

  • 类的构造函数即为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 条评论
登录 后参与评论

相关文章

来自专栏Google Dart

为控制器配置日期处理 原

471
来自专栏Kiba518

C#语法——泛型的多种应用

泛型是.NET Framework 2.0 版类库就已经提供的语法,主要用于提高代码的可重用性、类型安全性和效率。

813
来自专栏你不就像风一样

深入理解【代理模式】原理与技术

比如我们需要为一个业务方法在执行前后记录日志,为了达到解耦的目的,我们可以再新建一个类并定义一个新的业务方法,该方法既可以调用原业务方法,又可以在调用前后进行日...

1044
来自专栏Create Sun

基础拾遗------接口详解

  接口定义了所有类继承接口时应遵循的契约。接口定义了 "要什么" ,派生类定义了 "怎么给" 。  引用CLR VIA C#(类和接口继承)   在Mi...

3468
来自专栏Micro_awake web

JavaScript中创建对象的几种模式

820
来自专栏编码前线

Java注解Annotation

@Retention:保留时间,可选值SOURCE(源码)、CLASS(编译时)、RUNTIME(运行时);默认为CLASS,SOURCE大都为Mark Ann...

613
来自专栏Java工程师日常干货

Spring归纳小结

如果说有什么框架是Java程序员必然会学习、使用到的,那么Spring肯定是其中之一。本篇博客,将根据博主在日常工作中对Spring的使用做一个系统的归纳小结。

632
来自专栏Flutter入门

About Kotlin-Kotlin中的类1About Kotlin(1)

因为是从Java的角度来学习Kotlin,在Java中,类作为第一等公民。故学习Kotlin,也先从其的类开始。

863
来自专栏Kevin-ZhangCG

[ Java学习基础 ] Java的抽象类与接口

1736
来自专栏xingoo, 一个梦想做发明家的程序员

程序猿的日常——Java基础之抽象类与接口、枚举、泛型

再次回顾这些基础内容,发现自己理解的又多了一点。对于一些之前很模糊的概念,渐渐的清晰起来。 抽象类与接口 抽象类通常是描述一些对象的通用方法和属性,并且默...

17810

扫码关注云+社区