TypeScript的类和对象

一、TypeScript 类

TypeScript 是面向对象的 JavaScript。类描述了所创建的对象共同的属性和方法。TypeScript 支持面向对象的所有特性

1.1、类的定义

class class_name { 
    // 类作用域
}

类可以包含以下几个模块（类的数据成员）：

字段(属性) − 字段是类里面声明的变量。字段表示对象的有关数据。
构造函数 − 类实例化时调用，可以为类的对象分配内存。
方法 − 方法为对象要执行的操作。

例如：

class Car { 
    // 字段 
    engine:string; 
    // 构造函数 
    constructor(engine:string) {
         this.engine = engine 
    } 
    // 方法 
    disp():void { 
        console.log("发动机为 : "+this.engine) 
    }     
}

this 关键字表示当前类实例化的对象。注意构造函数的参数名与字段名相同，this.engine 表示类的字段。

1.2、创建实例化对象：使用 new 关键字来实例化类的对象，语法格式如下：

var object_name = new class_name([ arguments ])

类实例化时会调用构造函数，例如：

var obj = new Car("Engine 1")

类中的字段属性和方法可以使用 . 号来访问：

// 访问属性

obj.field_name

// 访问方法

obj.function_name()

示例：

// 创建一个对象
 var obj = new Car("XXSY1"); 
// 访问字段 
console.log("读取发动机型号 : " + obj.engine); 
// 访问方法 
obj.disp();

二、类的继承

TypeScript 支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。

类继承使用关键字 extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。

TypeScript 一次只能继承一个类，不支持继承多个类，但 TypeScript 支持多重继承（A 继承 B，B 继承 C）。

实例：

class Shape { 
    Area:number 
    constructor(a:number) { 
        this.Area = a 
    } 
}

class Circle extends Shape { 
    disp():void { 
    console.log("圆的面积: "+this.Area) 
    } 
} 

var obj = new Circle(223); 
obj.disp()

2.1、继承类的方法重写(overwrite)：又称为方法覆盖。类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。使用 super 关键字可以引用父类的属性和方法。

例如：

class PrinterClass { 
    doPrint():void { 
        console.log("父类的 doPrint() 方法。") 
    } 
} 

class StringPrinter extends PrinterClass { 
    doPrint():void { 
        super.doPrint() // 调用父类的函数
        console.log("子类的 doPrint()方法。") 
    } 
}

三、static 关键字：用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

例如：

class StaticMem { 
    static num:number; 
    static disp():void { 
        console.log("num 值为 "+ StaticMem.num) 
    } 
} 
StaticMem.num = 12 // 初始化静态变量 
StaticMem.disp() // 调用静态方法

四、instanceof 运算符：用于判断对象是否是指定的类型，如果是返回 true，否则返回 false。

class Person{ }

var obj = new Person()
var isPerson = obj instanceof Person; 
console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

五、类属性权限修饰符：TypeScript 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript 支持 3 种不同的访问权限。

public（默认） : 派生类、类的实例对象都可以访问。

class Person{
    public name:string;
    public age:number;
    constructor(name:strng,age:number){
        this.name=name;
        this.age=age;
    }
    cons(text:string){
      console.log(`Hi! ${this.name},${text}`);
    }
}

protected (保护属性): 派生类可以访问、类的实例对象不可以访问。

class Person{
    protected name:string;
    public age:number;
    constructor(name:strng,age:number){
        this.name=name;
        this.age=age;
    }
}
class Man extends Person{
    sex:string;
    constructor(name:strng,age:number,sex:string;){
        super(name,age)
        this.sex=sex
    }
    cons(text:string){
         console.log(`Hi! ${this.name},${text}`);
    }
}
new Man("Cat"，12).name; // 错误,name是保护属性

private (私有属性): 派生类、类的实例对象不可以访问。

class Person{
    private name:string;
    public age:number;
    constructor(name:strng,age:number){
        this.name=name;
        this.age=age;
    }
    cons(text:string){
      console.log(`Hi! ${this.name},${text}`);
    }
}
new Person("Cat"，12).name; // 错误: 'name' 是私有的.

readonly 修饰符：将属性设置为只读的。

class Person{
    readonly name:string;
    public age:number;
    constructor(name:strng,age:number){
        this.name=name;
        this.age=age;
    }
}
let dad =new Person("Cat"，12);
dad.name = "小明"; // 错误! name 是只读的.

六、存取器：TypeScript支持通过getters/setters来截取对对象成员的访问。

class Person{
    private _name:string;
    get name():string{
        return this._name;
    }
    set name(name:string){
        this._name=name;
    }
}
let man = new Employee();
man.name='小明';

七、TypeScript对象：对象是包含一组键值对的实例。值可以是标量、函数、数组、对象等，实例如下：

var object_name = { 
    key1: "value1", // 标量 
    key2: "value", 
    key3: function() { // 函数 }, 
    key4:["content1", "content2"] //集合 
}

1、对象字面量表示法

var person = {
    firstname:"Tom",
    lastname:"Hanks"
};
console.log(person.firstname)
console.log(person.lastname)

2、TypeScript 类型模板

var sites = { 
    site1: "Runoob", 
    site2: "Google", 
    sayHello: function () { } // 类型模板 
}; 
sites.sayHello = function () { 
    console.log("hello " + sites.site1); 
}; 
sites.sayHello();

3、对象作为函数参数

var person = {
    firstname:"Tom",
    lastname:"Hanks"
};
var invokeperson = function(obj: { firstname:string, lastname :string }) {
    console.log("first name :"+obj.firstname)
    console.log("last name :"+obj.lastname)
}
invokeperson(person);

4、匿名对象

var invokeperson = function(obj:{ firstname:string, lastname :string}) {
    console.log("first name :"+obj.firstname)
    console.log("last name :"+obj.lastname)
}
invokeperson({firstname:"Sachin",lastname:"Tendulkar"});

八、抽象类和抽象方法

用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
abstract抽象方法只能放在抽象类里面。
抽象类和抽象方法用来定义标准。

示例：Animal 类要求它的子类必须包含eat方法

abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract eat():any; //抽象方法不包含具体实现并且必须在派生类中实现。
    run(){
        console.log('其他方法可以不实现')
    }
}
//var a=new Animal() /*错误，抽象类不能实例化*/

class Dog extends Animal{
    constructor(name:any){
        super(name)
    }
    eat(){//抽象类的子类必须实现抽象类里面的抽象方法
        console.log(this.name+'吃粮食')
    }
}

var d=new Dog('小花花');
d.eat();
--------------------------------------------------------------
class Cat extends Animal{
    constructor(name:any){
        super(name)
    }
    run(){}
    eat(){ //抽象类的子类必须实现抽象类里面的抽象方法
        console.log(this.name+'吃老鼠')
    }
}

var c=new Cat('小花猫');
c.eat();

附：

面向对象的七大原则：

单一原则：一个类只负责一个职责。
里氏替换原则：子类可以在任何地方替换它的父类。
依赖倒置原则：代码要依赖于抽象的类，而不要依赖于具体的类；要针对接口或抽象类编程，而不是针对具体类编程。
接口隔离原则：提供尽可能小的单独接口，而不要提供大的总接口。暴露行为让后面的实现类知道的越少越好。
迪米特法则：尽量降低类与类之间的耦合。
开闭原则：面向扩展开放，面向修改关闭
组合/聚合复用原则：尽量使用合成/聚合达到复用，尽量少用继承。原则：一个类中有另一个类的对象。