Typescript学习笔记

Typescript

面向对象特性

类

类的声明

用class关键字 加类名

class Person {

    name;
    eat(){
        console.log(i'm eating);
    }
}

类声明完之后就可以被实例化了,类相当于一个模子.

class Person {

    name string;
    eat(){
        console.log(i'm eating);
    }
}

var  p1 = new Person();
p1.name = "batman";
p1.eat();
var  p2 = new Person();
p2.name = "superman";
p2.eat();

访问控制符:在声明类的属性和方法的时候可以为它们指定访问控制符.
作用:可以控制类的属性和方法是否可以在类的外部被访问到
共三个:
public:默认的,如果属性和方法前面什么都没写就是默认public ,在类的外部和内部都可以被访问到.
private:只有在类的内部被访问到.
protected 在类的内部和子类里能访问到

class Person {
    //公开的
    public name:string;
    public eat(){
            console.log(i'm eating);
        }
    //私有的
    private age;
    private eatMuch(){
    }
}

类的构造函数

class Person {
    //构造函数
    constructor(){
    }

}

类的构造函数之后在类被实例化new的时候才会被调用,只调用这一次
在外部访问不到这个方法.
作用:当我要实例化一个类的时候,想要必须为这个实例指定一个属性的时候.
比如,我要实例话Person类,必须为他指定一个名字

class Person {
    name:string;
    constructor(name:string){
        this.name = name
    }

}
var p1 = new Person();//这里就不能这么写了
//要写成这样
var p1 = new Person("batman");
p1.eat();

我们这里为类声明了一个name属性,在实例话的时候,为这个name属性赋了一个值.
以上可以简化

//完整版
class Person {
    name:string;
    constructor(name:string){
        this.name = name
    }

}
//简化版
class Person {

    constructor(public name:string){

    }

}

这里需要注意:如果用简写,那构造函数上声明要明确的写上访问控制符public也是不能被省略的

class Person {
    //这样写是声明了一个name属性的
    constructor(public name:string){

    }   
    //这样写是没有声明name属性
    constructor(name:string){

    }       
}

类的继承

关键字
extends
super

class Employee extends Person {

}

当一个类用extends关键字继承另一个类的时候,这个类就会获得它所继承的那个类的所有属性和方法.
在Employee类里声明自己的属性和方法

class Employee extends Person {
    code:string;
    work(){
    }
}

关键字super:
第一个用法是调父类的构造函数

假设,我们在实例化一个雇员的时候,必须要给他起一个名字还必须给她一个工号

class Employee extends Person {
    //子类的构造函数必须要调用父类的构造函数
    constructor(name:string,code:string){
        super(name);
        this.code = code;
    }
    code:string;
    work(){
    }
}

var e1 = new Employee("batman","1");

super相当于是es5中,构造函数的伪装

super关键字的第二个用法:调父类的其他方法

super.eat()

接口(interface)

用来建立某种代码约定,使得其他开发者在调用某个方法或创建新的类时必须遵循接口所定义的代码约定.
两个关键字
interface用来声明一个接口
implements用来实现一个接口

//声明一个接口
interface IPersin {
    //接口里面和类的声明一样 
    name:string;
    age:number;
}

class Person {
    constructor(public config: IPerson){
    }
}

以上先声明了一个接口,然后创建了一个类,在类里使用了这个接口
接口的第一个用法:它作为一个方法的参数的类型声明
这样当我在调用这个方法的时候typescript会去检查你的方法是否满足这个接口要求声明的那些属性

var p1 = new Person({
    name:"zhangsan",
    age:18
});

调用这个方法的时候必须传一个对象参数进去,这个对象里必须写上name属性和age属性,这样typescript才不会报错.
注意:这里多传一个属性或者少传一个属性都会报错,因为你没有满足这个接口所声明的属性的要求

接口的第二个使用方式:

interface Animal {
    eat()
}
class Sheep implements Animal {
    //这里必须实现接口里声明的方法
    eat(){
    //定义自己的eat方法
    console.log("i eat grass")
    }
}
class Tiger implements Animal {
    eat(){
        console.log("i eat meat");
    }
}

实现这个接口的类,必须实现接口中定义的方法

泛型(generic)

参数化的类型,一般用来限制集合的内容

var worker:Array<Person> = [];

以上Person就是这个数组的泛型,它规定了这个数组里只能放Person

worker[0] = new Person("zhangsan");
worker[1] = new Employee("lisi");

参数新特性

参数类型:
在参数名称后面使用冒号来指定参数类型

var myname:string = "zhuzhuxia"

想要它又是字符串又可以是数字就用any
void用来声明一个方法是否有返回值

可以声明类型的位置:在变量,方法,和方法的参数后面声明类型

自定义类型:

class Person {
    name:string;
    age:number;
}
var zhangsan:Person = new Person();