类

介绍

传统的JavaScript程序使用函数和基于原型的继承来创建面向对象的类，在es6中，JavaScript程序员能够使用基于类的面向对象的方式，通过引入class关键字，表示定义一个类。TypeScript中允许开发者使用这些特性。

类的定义

其实typescript中定义类的方法与ES6相同，在ES6的基础上，加了类型检查。

//es6中定义类的方法:
class Person {
     constructor(name){
        this.name = name;    
     }
     run() {
        console.log(this.name);
     }
}
//ts中定义类的方法
class Person {
    public name:string;    //  public关键字可省略
    constructor(name:string){   //构造函数   实例化类的时候触发的方法
        this.name = name;     
    }
    run():void {
        console.log(this.name);
    }
}
// 执行方法
var p=new Person('张三');
p.run()

继承

在TypeScript中，我们可以使用常用的面向对象模式。可使用继承(关键字extends、super)来扩展现有的类。

class Person {
    public name:string;    //  public关键字可省略
    constructor(name:string){   //构造函数   实例化类的时候触发的方法
        this.name = name;     
    }
    run():void {
        console.log(this.name);
    }
}
class Web extends Person{
    constructor(name:string){
        super(name);    // 初始化父类的构造函数，必须调用super();
    }
}
var w=new Web('张三');
w.run()

上述例子展示了基本的继承：类从基类中继承了属性和方法。这里， Web是一个派生类，它派生自Person基类，通过extends关键字。派生类通常被称作子类，基类通常被称作超类.
因为Web继承了Person的功能，因此Web的实例能够执行run方法。

当子类中定义的方法和父类一致时，会执行子类中的方法，这是原型链的查找规则。

类中的修饰符(public、protected、private)

public :公有，在当前类里面、 子类 、类外面都可以访问；
protected：保护类型，在当前类里面、子类里面可以访问 ，在类外部没法访问
private ：私有 ，在当前类里面可以访问，子类、类外部都没法访问

默认为public

在TypeScript中，成员默认为public，也可以明确将一个成员标记为public。上面的例子也可这么写：

class Person {
    public name:string;    //  public关键字可省略
    public constructor(name:string){   //构造函数   实例化类的时候触发的方法
        this.name = name;     
    }
    public run():void {
        console.log(this.name);
    }
}
var p=new Person('张三');
p.run()

理解protected

protected类型的成员在当前类和子类中都可以访问，但不能在类外部访问。

// 类外部无法访问保护类型的属性
class Person {
    protected name:string;    
    constructor(name:string){   
        this.name = name;     
    }
    run():void {
        console.log(this.name);
    }
}
class Web extends Person{
    constructor(name:string){
        super(name);   //  这里仍可以访问name，因为web是由person类派生来的
    }
}
var p=new Person('张三');
p.name;  //  error    不能在类外部使用protected类型变量或方法

注意：当派生类构造函数被标记为protected。这意味着这个类不能在包含它的类外被实例化，但是能被继承。

理解private

当成员被 标记成private时，它就不能在声明它的类的外部访问。

class Person {
    private name:string;    
    constructor(name:string){   
        this.name = name;     
    }
    run():void {
        console.log(this.name);
    }
}
class Web extends Person{
    constructor(name:string){
        super(name);   
    }
    work():void {
        console.log(this.name);  //  error  私有变量不能在子类中使用
    }
}
var p=new Person('张三');
p.name;  //  error  私有变量不能在类外部使用

静态属性 静态方法

静态属性及方法存在于类本身而不是类的实例上。使用static关键字定义，如果实例对象想访问静态属性，需在属性age前加类名Person，如下例：

class Person {
    name:string;    
    static age:number = 20;
    constructor(name:string){   
        this.name = name;     
    }
    static run():void {
        console.log(this.name);
    }
    work():void{ 
          console.log(Person.age);  //  访问静态属性，必须使用类Person调用
    }
}
var p = new Person('张三');
p.run();  //  error   访问静态方法，必须使用类调用
Person.run();   // right

抽象类 多态

抽象类作为其他派生类的基类，一般不会直接被实例化。使用abstract关键字定义抽象类和抽象方法。

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。abstract抽象方法只能放在抽象类里面。

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 Animal {
     name:string;
     constructor(name:string) {
         this.name=name;
     }
     eat(){   //具体吃什么  不知道 ?继承它的子类去实现 ，每一个子类的表现不一样
         console.log('吃的方法')
    }
}
class Dog extends Animal{
    constructor(name:string){
         super(name)
    }
   eat(){
       return this.name+'吃粮食'
   }
}
 class Cat extends Animal{
    constructor(name:string){
       super(name)
    }
    eat(){
      return this.name+'吃老鼠'
   }
}
var d = new Dog('小狗');
var c = new Cat('小花');
d.eat();  // 小狗吃粮食
c.eat();  //  小花吃老鼠
//  对于同一个方法每个子类实例有不同的表现

接口

接口的作用：在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范，在程序设计里面，接口起到一种限制和规范的作用。接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类里方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可以满足实际需要。 typescript中的接口类似于java，同时还增加了更灵活的接口类型，包括属性、函数、可索引和类等。

属性类接口

ts中当自定义方法需对传入的参数进行约束时，我们可以这样定义：
约束传入的参数必须是对象，并且有label属性

function printLabel(labelInfo:{label:string}):void {
   console.log('printLabel');
}
printLabel('hahah'); //错误写法
printLabel({name:'张三'});  //错误的写法
printLabel({label:'张三'});  //正确的写法

当需要对批量方法传入的参数进行更新时，可引入接口：行为和动作的规范，对批量方法进行约束.

interface FullName{
     firstName:string;   //注意;结束
     secondName:string;
}
function printName(name:FullName){
     // 必须传入对象  firstName  secondName
    console.log(name.firstName+'--'+name.secondName);
}
printName('1213');  //错误
var obj={   /*传入的参数必须包含 firstName  secondName*/
     age:20,
     firstName:'张',
    secondName:'三'
};
printName(obj);   //  输出“张--三”

当接口里的属性不全都是必需的，在某些条件下存在，或者根本不存在时，可在可选属性名字定义的后面加?符号

函数类型接口

函数类型接口：对方法传入的参数以及返回值进行约束

interface encrypt {
  (key:string, value:string):string;
}
var md5:encrypt = function(key:string, value:string):string {
  return key+value;
}
console.log(md5('name', 'zhangsan'));

对于函数类型的类型检查来说，函数的参数名不需要与接口定义的名字相匹配，比如用下面的代码重写上面的例子：

var md5:encrypt = function(source:string, src:string):string {
  return source+src;
}

类类型接口

对类的约束，和抽象类有点相似
在C#或Java中，接口通常是用来定义一个类的公共部分，然后创建一个类，通过implements关键字去实现接口。

在接口中描述方法，在类里实现它。

interface Animal{
   name:string;
   eat(str:string):void;
}
class Dog implements Animal{
    name:string;
    constructor(name:string){
      this.name=name;
    }
    eat(){
      console.log(this.name+'吃粮食')
    }
}
var d=new Dog('小黑');
d.eat();

可索引接口

可索引接口：是对数组、对象的约束。不太常用

//可索引接口 对数组的约束
interface UserArr{   
  [index:number]:string
}
var arr:UserArr=['aaa','bbb'];
console.log(arr[0]);
var arr:UserArr=[123,'bbb'];  /*错误，索引的值只能是string*/
console.log(arr[0]);

 //可索引接口 对对象的约束
// 索引为string类型，值也为string类型
interface UserObj{
     [index:string]:string
}
var arr:UserObj={name:'张三'};

扩展接口：接口可以继承接口

interface Animal{
  eat():void;
}
interface Person extends Animal{
  work():void;
}
class Programmer{
    public name:string;
    constructor(name:string){
       this.name=name;
    } 
    coding(code:string){
        console.log(this.name+code)
    }
}
class Web extends Programmer implements Person{
     constructor(name:string){
         super(name)
     }
     eat(){
         console.log(this.name+'喜欢吃馒头')
     }
     work(){
      console.log(this.name+'写代码');
   } 
}
var w=new Web('小李');
w.eat();
w.coding('写ts代码');

在上面例子中，定义了两个接口Animal和Person ，其中Person继承自Animal，又定义programmer类，具有name属性和coding方法，定义的Web类继承自Programmer并实现了Person接口，因此Web实例也有name属性和Animal、Person接口的方法eat、work、coding

上一篇TypeScript基础入门（三）主要介绍ts中的函数