class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    greet() {
        return "Hello," + this.greeting;
var user = new Greeter("World!");

document.writeln(user.greet());

class Animal {
    name: string;
    constructor(theName: string) {
        this.name = theName;
    move(meters: number = 0) {
        alert(this.name + "移动了" + meters+"米");
class Snake extends Animal {
    constructor(name: string) {
        super(name);
    move(meters = 5) {
        alert("我是蛇，我在滑行...");
        super.move(meters);
class Horse extends Animal {
    constructor(name: string) { super(name) }
    move(meters = 45) {
        alert("我是马，我在奔跑！");
        super.move(meters);
var snakeObj = new Snake("眼镜蛇");

var horseObj: Animal = new Horse("千里马");

snakeObj.move();

horseObj.move(1000);

class Animal {
    private name: string;
    constructor(theName: string) {
        this.name = theName;
    move(meters: number = 0) {
        alert(this.name + "移动了" + meters+"米");
理解private
TS是一个结构型系统。当比较两个不同的类型时，不用考虑它们来自哪里，如果它们的每一个成员的类型是兼容的，那么我们就说这两个类型是兼容的。
当比较具有private成员的类型时，我们就要具体分析了。对于两个兼容的类型而言，如果其中一个类有一个private成员，那么另外一个必须要有一个产生自相同声明的private成员（换言之，共用同一个声明）。
来通过一个实例来更好地理解：
class Animal {
    private name: string;
    constructor(theName: string) {
        this.name = theName;
class Snake extends Animal {
    constructor(name: string) {
        super(name);
class Employee {

private name: string;

constructor(theName: string) {

this.name = theName;

var animalObj = new Animal("公鸡");

var snakeObj = new Snake("蛇");

var emloyeeObj = new Employee("雇员");

animalObj = snakeObj;

animalObj = emloyeeObj;//报错，因为Employee类有name的私有声明，不能把它复值给animalObj的name属性

在这个例子中，我们有三个类，其中”Snake”是Animal的子类。我们也创建了一个看上去和Animal样子一样的新类”Employee“。我们也创建了这些类的 实例，并把它们相互赋值看会发生什么。因为Animal和Snake共享同一个Animal中的声明”private name:string“，所以它们是兼容的。然而，这对Employee不是这样。当尝试将一个Employee对象赋值给Animal时，会得到一个类型不兼容的错误。虽然Employee也有一个名为name的私有成员，但是它和Animal中的那个私有成员不是同一个。
通过创建参数类型，public和private关键字也是创建和初始化类的成员快捷方式。该属性能够让你一步创建和初始化一个成员。看下面我们修改之前例子的代码。注意我们是如何不使用”theName“而在constructor上使用快捷的”private name：string”来创建并初始化name参数。
class Employee {
    constructor(private name: string) {
    move(meters: number = 0) {
        alert(this.name + "移动了" + meters+"米");
用这种方式使用private来创建和初始化一个private成员，对于public也是同样的道理。
TS支持getters和setters作为访问一个对象成员拦截方式。这对于每个对象上的一个成员是如何被访问的提供了一种细粒度控制的方式。
下面使用get和set来转换一个类。首先，先不使用setter和getter来开始这个例子。
class Employee {
    fullName: string;
var obj = new Employee();
obj.fullName = "tkb至简";
if(obj.fullName){
    alert(obj.fullName);
虽然允许人们直接随意地设置fullName相当方便，但是如果人们突发奇想就可以改变名字，这会让我们很困惑。
在下面这个版本中，我们允许用户修改雇员之前，先要检测确保用户有一个有效的安全密码。我们可以使用会检测安全密码的set来取代直接访问fullName。我们添加一个相应的get来允许之前的例子继续无缝运行。
var passcode = "123456";
class Employee {
    private _fullName: string;
    get fullName(): string {
        return this._fullName;
    set fullName(newName: string) {
        if (passcode && passcode == "123456") {
            this._fullName = newName;
        } else {
            alert("您没有权限修改雇员信息！");
var obj = new Employee();
obj.fullName = "tkb至简";
if (obj.fullName) {
    alert(obj.fullName);
为了证明访问器现在正在检查安全码，我们可以修改安全码来看当安全码不匹配的时候，会不会弹出一个对话框说“您没有权限修改雇员信息！”。
修改passcode为12345时，弹出错误提醒：
注意：访问器要求你必须将编译器设置为输出ECMAScript 5。
说到这里，我们目前只讨论了类的实例成员，它们只有当类实例化时才会出现在对象上。我们也可以创建静态成员，它们对于类自身都是可见的而不是实例。下面的例子，我们在origin上使用了static关键字，因为它对于所有的grids都是通用的。每一个实例都可以通过附加的类名来访问这个值。和实例访问之前加上this关键字相似。
class Grid {
    static orgin = { x: 0, yield: 0 };
    calculateDistanceFromOrgin(point: { x: number,y:number }) {
        var xDist = point.x - Grid.orgin.x;
        var yDist = point.y - Grid.orgin.y;
        return Math.sqrt(xDist * xDist + yDist * yDist) * this.scale; 
    constructor(public scale: number) {}
var grid1 = new Grid(1.0);//比例尺为1
var grid2 = new Grid(5.0);//比例尺为5
alert(grid1.calculateDistanceFromOrgin({ x: 10, y: 10 }));
alert(grid2.calculateDistanceFromOrgin({ x: 10, y: 10 }));
高级技术点
在TS中声明一个类的时候，实际上是一次创建了多个声明。第一个是实例类的类型。
class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    greet() {
        return "Hello," + this.greeting;
var user:Greeter;
user = new Greeter("World!");

document.writeln(user.greet());

这里，当我们声明”var user:Greeter;”时，我们使用了Greeter作为Greeter类的实例的类型。这个对于来自面向对象语言的程序员来说几乎是第二个特性。
我们也通过调用构造函数创建其他值。这个函数是在我们new出类的实例的时候调用的。为了理解实践中它是什么样子，让我们通过上面的TS代码生成的JS代码来看一下：
var Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    Greeter.prototype.greet = function () {
        return "Hello," + this.greeting;
    return Greeter;
})();
var user = new Greeter("World!");
document.writeln(user.greet());
这里，“var user”将会被构造函数赋值。当我们调用new并运行这个函数的时候，我们得到了该类的一个实例。构造函数也包含了该类的所有静态成员。思考每个类的另外一种方式是类有实例的一面和静态的一面。
稍微修改一下例子看一下不同：
class Greeter {
    static standardGreeting = "Hello,There";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello," + this.greeting;
        } else {
            return Greeter.standardGreeting;
var user: Greeter;

user = new Greeter();

alert(user.greet());
var greetMaker: typeof Greeter=Greeter;

greetMaker.standardGreeting = "Hey,there!";

var user2: Greeter = new greetMaker();

alert(user2.greet());

这个例子中，“user”和之前运行相似。我们实例化Greeter类，然后使用了这个对象。这个之前已经看到过。
下一个，然后我们直接只用类。这里我们创建了一个新的变量叫做“greetMaker”。这个变量保持了类本身，或者说成是它的构造函数。这里我们使用了typeof Greeter，意思是“给我们Greeter类本身的类型”而不是类型的实例。或者，更准确地说，“给我叫做Greeter的标志的类型”，它是构造函数的类型。这个类型包含了Greeter的所有的静态成员和创建Greeter类实例的构造函数。
使用类作为接口
正如之前说的，一个类的声明创建了两样东西：代表类的实例的类型和构造函数。因为类创建了类型，所以你可以在你可以使用接口的地方使用它们，例如：
class Point {
    x: number;
    y: number;
interface Point3D extends Point {

z: number;

var point3D: Point3D = { x: 1, y: 2, z: 3 };

    如果您认为这篇文章还不错或者有所收获，您可以通过右边的“打赏”功能 打赏我一杯咖啡【物质支持】，也可以点击右下角的【好文要顶】按钮【精神支持】，因为这两种支持都是我继续写作，分享的最大动力！
    
作者：tkb至简

    
来源：http://farb.cnblogs.com/
    
声明：原创博客请在转载时保留原文链接或者在文章开头加上本人博客地址，如发现错误，欢迎批评指正。凡是转载于本人的文章，不能设置打赏功能，如有特殊需求请与本人联系！
已将所有赞助者统一放到单独页面！签名处只保留最近10条赞助记录！查看赞助者列表