TypeScript学习笔记（二）

先介绍ES5的类

1.最简单的类

function Person(){

  this.name="zhangsan";
  this.age=20;
}
var p=new Person();
alert(p.name);

2.构造函数和原型类里面增加方法

function Person(){

  this.name="zhangsan";
  this.age=20;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}

}
var p=new Person();
p.run();

3.类里面的静态方法（与实例方法相对，实例方法就是必须要先创建实例，然后才能调用的方法，而静态方法则不需要先创建实例）

function Person(){

  this.name="zhangsan";
  this.age=20;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}
Person.getInfo(){
   alert(我是静态方法);
}

}
/**调用静态方法**/
Person.getInfo();

4.继承

function Person(){

  this.name="zhangsan";
  this.age=20;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}

function Web(){
   Person.call(this);/**对象冒充继承形式**/
}
var w=new Web();
w.run*();
w.work();/**会报错！！！！，对象冒充的继承形式可以继承构造函数，但是不能继承原型链中的函数**/

原型链实现继承可以继承构造函数，也可以继承原型链中的函数

function Person(){

  this.name="zhangsan";
  this.age=20;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}
function Web(){
 
}
Web.prototype= new Person();
var w=new Web();
w.run();//ok
w.work();//ok

但是也带来了一个问题：实例化的子类没办法给父类传参

function Person(name,age){

  this.name=name;
  this.age=age;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}
function Web(){
 
}
Web.prototype= new Person();
var w=new Web("zhangsan",21);
w.run();//erro

web类继承Person类原型链+对象冒充的组合继承模式

function Person(name,age){

  this.name=name;
  this.age=age;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}
function Web(){
  Person.call(this,name,age);//对象冒充！！！！
}
Web.prototype= new Person();//原型链！！！！
var w=new Web("zhangsan",21);
w.run();//erro

web类继承Person类原型链+对象冒充的组合继承的另一种模式

function Person(name,age){

  this.name=name;
  this.age=age;
  this.run=function(){
  alert(this.name+"在运动");
  }
  /**原型链上的属性会被多个实例共享，但是构造函数不会**/
Person.prototype.sex="man";
Person.prototype.work=function(){
alert(this.name+"在工作");
}
function Web(){
  Person.call(this,name,age);
}
Web.prototype= Person.prototype;//另一种模式!!!
var w=new Web("zhangsan",21);
w.run();

先介绍ts的类

1.定义类

class Person{
   name:string;
   constructor(n:steing){/**构造函数**/
      this.name=n;
  }/**这一段跟es5定义一个简单类的作用相同**/

 run():void{
    alert(this.name);
  }
}

var p=new Person("zhangsan");
p.run();

2.类的继承(extend，super)

class Person{
   name:string;
   constructor(name:steing){/**构造函数**/
      this.name=name;
  }/**这一段跟es5定义一个简单类的作用相同**/

 run():string{
    return "4(this.name)在运动";
  }
}

var p=new Person("王五");//实例创建后，王五传给类的构造函数，然后传给类的name赋值
alert(p.run());

写一个web继承person

class Web extends Person{
}
var w=new Web("zhangsan");//这会报错！！！

正确写法

class Web extends Person{
  constructor(name:string){/**构造函数**/
       super(name);//初始化父类的构造函数
  }
}
var w=new Web("zhangsan");

子类可以写同名方法，子类调用时，先检查子类有没有该方法，没有再继承父类。
子类可以写自己的方法

class Web extends Person{
  constructor(name:string){/**构造函数**/
      super(name);//初始化父类的构造函数
  }
 
  work():string{
    alert('$(this.name)在工作‘）；
 }
}
var w=new Web("zhangsan");
w.work();

3.类的修饰符
ts提供了三种修饰符，如下表：

修饰符	特点
public	公有，在当前类的子类，以及类外面均可以使用
protect	保护，在当前类，子类可以使用，在类外不能使用
privatet	私有，只能在当前类中使用，在子类，父类可以，类外不能使用

注：如果不加修饰符，默认为public属性

4.类的静态方法和静态属性

class Web extends Person{
  constructor(name:string){/**构造函数**/
      super(name);//初始化父类的构造函数
      static sex:string;//静态属性
  }
 
  work():string{//实例方法
    alert('$(this.name)在工作‘）；
 }
  static print(){//静态方法
     alert('静态方法'+Perosion.sex);//此处没办法直接调用类里面的属性,可以调用静态属性
  }
}
var w=new Web("zhangsan");
w.work();//先创建实例，才能调用实例方法
Person.print();//静态方法的调用

5.类的多态
多态：父类定义一个方法却不实现，让继承它的多个子类实现该方法，并且每一个子类表现不一样。多态属于继承

class Animal{
  name:string;
  constructor(name:string){
    this.name=name;
  }
eat(){//具体吃什么不知道
  console.log('吃的方法')
  }
}

class Dog extends Animal{

constructor(name:string){
    super(this.name);
  }
  eat(){
    return this.name+'吃骨头';
  }
}

class Cat extends Animal{

constructor(name:string){
    super(this.name);
  }
  eat(){
   return this.name+'吃鱼';
  }
}

6.抽象类
1.使用abstract关键字来定义抽象方法和抽象类
2.抽象类不能被实例化,它提供一个基类，也不能给出具体的实现，而在其子类中必需给出具体实现
3.抽象方法必须放在抽象类中
4.抽象类，必须（最好）包含抽象方法

//定义抽象lei
 abstract class Animal{
   abstract eat():void;
}