通常用class定义一个类

  1. class Person{
  2.     name:string
  3.     age:number
  4.     constructor(name:string,age:number){
  5.         this.name = name;
  6.         this.age = age;
  7.     }
  8.     getName():void{
  9.         console.log(this.name);
  10.     }
  11. }
  12. var p:Person = new Person("cheng",20);
  13. p.getName();
  1. #当没有构造函数的时候,代码底层有自动补全构造函数
  2. class Person{
  3.     /* 实例的name */
  4.     name:string
  5.     age:number
  6.     getName():void{
  7.         console.log(this.name);
  8.     }
  9. }
  10. var p:Person = new Person();
  11. p.getName();

2.3.1、static

  1. #static修饰的变量是类所共有的,只能通过类名去调用。
  2. class Person{
  3.     /* 实例的name */
  4.     static skill:string = "js";
  5.     name:string
  6.     age:number
  7.     getName():void{
  8.         console.log(Person.skill)
  9.         console.log(this.name);
  10.     }
  11. }
  12. var p:Person = new Person();
  13. p.getName();

2.3.2、泛型

  1. 泛型：任意类型
  2. 好处：兼顾了灵活性和类型检查
  1. #定义一个泛型函数
  2. function goTest<T>(s:T):T{
  3.     return s;
  4. }
  5. goTest<string>("1000");
  6. goTest<number>(100);
  1.  function goTest<T>(s:T):T{
  2.      return s;
  3.  }
  4.  /* 灵活性或类型检查 */
  5.  /* 泛型：任意类型 */
  6.  var arrr:Array<number> = [1,2,3];
  7.  goTest<string>("1000");
  8.  goTest<number>(1000);
  9.  goTest<object>({name:"cheng"});