TypeScript学习(四)：面向对象之类，接口，泛型，命名空间，模块

javascript其实也可以定义类，只是typescript封装以后，变得更像面向对象语言了，几乎和c#,java语法一致。

//一切皆对象，类是对象的抽象描述，对象是类的实例

//类，接口，继承，泛型

//避免重复定义的错误，外部定义一个立即执行的函数（function（）{}）（）来包装一下，测试用

(function(){

    //1.Person类，定义类和java,c#语言类似

    class Person{

        /**

         * 定义属性_name,_age

         * private表示只能在当前类内部方法，

         * 默认是public，子类和其他类内部都能访问

         * protected,当前类及子类能访问

         *

         *

         * */

        private _name:string;

        private _age:number;

        //构造函数,this表示当前new出来的对象

        constructor(name:string,age:number)

        {

            this._name=name;

            this._age=age;

        }

        //给name属性赋值，调用的时候直接p.name

        set name(name:string)

        {

            this._name=name;

        }

        //获取name属性，调用的时候直接p.name

        get name()

        {

            return this._name;

        }

        set age(age:number)

        {

            this._age=age;

        }

        get age()

        {

            return this._age;

        }

    }

    //2.类定义的简写方式，等同上面的Person类定义

    console.log("-------简写方式测试,加上public直接将属性定义在构造函数中，表示外部可以访问，不加默认private外部不能访问------");

    class NewPerson{

        constructor(public name:string,age:number){

        }

    }

    const np=new NewPerson("andy",19);

    console.log(np);

    console.log(np.name);

    //console.log(np.age);//age不是public无法访问

    //3.定义动作接口

    interface Action{

        actionName:string;

        run():void;

        read(book:string):void;

        exam(subject:string):number;

    }

   

    //4.Student继承Person类，实现接口Action

    class Student  extends Person  implements Action{

        //定义属性

        private _studentNo:string;

        private _className:string;

        //定义构造函数

        constructor(name:string,age:number,studentNo:string,className:string)

        {

            //必须调用父类的构造函数

            super(name,age);

            this._studentNo=studentNo;

            this._className=className;

        }

        //给接口属性赋值

        actionName: string="做一些动作";

       

        //必须实现接口的3个方法

        run(): void {

            console.log("我在跑步");

        }

        read(book: string): void {

            console.log("我在读书,书名是:"+book);

        }

        exam(subject: string): number {

            console.log("我在参加"+subject+"考试,考了100分");

            return 100;

        }

         //调用的时候直接p.studentNo

         set studentNo(studentNo:string)

         {

             this._studentNo=studentNo;

         }

         //调用的时候直接p.studentNo

         get studentNo()

         {

             return this._studentNo;

         }

         set className(className:string)

         {

             this._className=className;

         }

         get className()

         {

             return this._className;

         }

    }

    //5.const一般用来声明变量，readonly用来修饰类或者接口的属性，表示初始化之后不能被修改

    const p=new Person("jack",10);

    console.log(p);

    //属性默认是public加上private 就不能直接访问_name,_age,需要通过方法来访问

    p.name="mary";

    p.age=8;

    console.log(p);

 

    let s=new Student("sam",18,"000000002","三一班");

    console.log(s);

    s.run();

    s.read("钢铁是怎样炼成的");

    s.exam("数学");

 

    //6.定义泛型T,泛型的意思是类型不确定，调用是可以根据需要来传递类型

    function test1<T>(p1:T):T{

        return p1;

    }

    //定义泛型T,K

    function test2<T,K>(p1:T,p2:K):T{

        return p1;

    }

    //不指定类型

    console.log(test1(100));

    //指定类型

    console.log(test1<string>("hello,world!"));

})();

//7.和java,c#一样，ts也有命名空间,命名空间可以解决类型重名问题，另外也便于代码的组织

//通过SomeNameSpaceName.SomeClassName;访问命名空间下面的类

//如果一个命名空间在一个单独的 TypeScript 文件中，则应使用三斜杠 /// 引用它，语法格式如下：

/// <reference path = "SomeFileName.ts" />

//定义了Drawing名称空间下的IShape接口，该接口含一个方法draw，定义为IShape.ts文件

//export之后，外部才能使用

namespace Drawing {

    export interface IShape {

        draw():void;

    }

}

// 外部通过reference引用

//定义了Drawing名称空间下的类Circle继承IShape接口，定义为Circle.ts文件

///<reference path = "IShape.ts" />

namespace Drawing {

    export class Circle implements IShape {

        public draw() {

            console.log("Circle is drawn");

        }  

    }

}

//外部通过reference引用 <reference path = "IShape.ts" />

//定义了Drawing名称空间下的类Triangle继承IShape接口，定义为Triangle.ts文件

///<reference path = "IShape.ts" />

namespace Drawing {

    export class Triangle implements IShape {

        public draw() {

            console.log("Triangle is drawn");

        }

    }

}

//绘画方法，参数为Drawing.IShape接口

/// <reference path = "IShape.ts" />  

/// <reference path = "Circle.ts" />

/// <reference path = "Triangle.ts" />  

function drawAllShapes(shape:Drawing.IShape) {

    shape.draw();

}

drawAllShapes(new Drawing.Circle());

drawAllShapes(new Drawing.Triangle());

//8.模块

命名空间是为了解决，类重名问题，模块就是假设新建了一个ts文件，那其他ts怎么引用这个ts文件里面定义的方法呢？

通过export导出当前ts接口或者类和import来引用外部接口或者类

// 文件名 : SomeInterface.ts 
export interface SomeInterface { 
   // 代码部分
}

要在另外一个文件使用该模块就需要使用 import 关键字来导入:

import someInterfaceRef = require("./SomeInterface");

假设定义了一个形状的接口，圆形类继承了这个接口， 另外一个类里面又使用圆形这个类。那么这么写。

IShape.ts文件：

export interface IShape {

    draw():void;

 }

Circle.ts文件：

//引入IShape.ts

import shape = require("./IShape");

export class Circle implements shape.IShape {

   public draw() {

      console.log("Cirlce is drawn (external module)");

   }

}

TestShape.ts文件：

//引入需要的文件

import shape = require("./IShape");

import circle = require("./Circle");

function drawAllShapes(shapeToDraw: shape.IShape) {

   shapeToDraw.draw();

}

drawAllShapes(new circle.Circle());