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());
