TypeScript(二)--类

3.4 类

3.4.1 es5中的类：

function Person() {
  this.name = '张三'；
  this.age= 20；
  // 在构造函数中增加方法
  this.run= function() {
    alert(this.name);
  }
}
//原型链上增加方法：
// 原型链上的属性会被多个实例共享，构造函数不会
Person.prototype.sex = '男';
Person.prototype.work = function() {
  alert(this.name+'在工作');
}
var p = new Person();

p.run();
p.work();

类中的静态方法：

function Person() {
  this.name = '张三'；
  this.age= 20；
  // 在构造函数中增加方法
  this.run= function() { // 实例方法
    alert(this.name);
  }
}
//原型链上增加方法：
// 原型链上的属性会被多个实例共享，构造函数不会
Person.prototype.sex = '男';
Person.prototype.work = function() {
  alert(this.name+'在工作');
}
Person.getInfo = function() {
  alert('静态方法：');
}
var p = new Person();

p.run();
p.work();

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

es5 继承：

function Person() {
  this.name = '张三'；
  this.age= 20；
  // 在构造函数中增加方法
  this.run= function() { // 实例方法
    alert(this.name);
  }
}
Person.prototype.sex = '男';
Person.prototype.work = function() {
  alert(this.name+'在工作');
}
// 定义web类 继承Person类 原型链+对象冒充的组合继承
function Web() {
  Person.call(this); // 对象冒充实现继承
}
var w = new Web();
w.run();// 对象冒充可以继承构造函数里面的属性和方法
w.work(); // 直接报错，无法继承原型链上面的属性和方法。

原型链实现继承：

function Person(name, age) {
  this.name = name；
  this.age= age；
  // 在构造函数中增加方法
  this.run= function() { // 实例方法
    alert(this.name);
  }
}
Person.prototype.sex = '男';
Person.prototype.work = function() {
  alert(this.name+'在工作');
}
function Web() {
  
}
Web.prototype = new Person(); // 既可以继承构造函数中的属性方法也可可继承原型链上的方法 

var w = new Web('wangwu', 23); // 实例化子类的时候无法给父类传参
w.run(); 
w.work();

原型链+对象组合实现继承

function Person(name, age) {
  this.name = name；
  this.age= age；
  // 在构造函数中增加方法
  this.run= function() { // 实例方法
    alert(this.name);
  }
}
Person.prototype.sex = '男';
Person.prototype.work = function() {
  alert(this.name+'在工作');
}
function Web() {
  Person.call(this,name,age); // 对象冒充继承，实例化子类可以给父类传参
}
Web.prototype = new Person(); // 既可以继承构造函数中的属性方法也可可继承原型链上的方法 
// or
Web.prototype = Person.prototype;// 无法区分对象的实例还是子类的实例

// 优化：
## 创建一个中间对象，同时把父类的原型对象赋初值：
Web.prototype = Object.create(Person.prototype);
## 区分了父类和子类的原型对象关系
Web.prototype.constructor = Web;

var w = new Web('wangwu', 23); // 实例化子类的时候无法给父类传参
w.run(); 
w.work();

3.4.2 ts中的类：

class Person{
  // 定义属性：
  name:string, // 前面省略了public关键词
  constructor(name:string) { // 构造函数  实例化类的时候出发的方法
    this.name = name
  }
	run():void{
    alert(this.name);
  }
}
// 实例化：
var p = new Person('张三');
p.run();

class Person{
  // 定义属性：
  name:string, // 前面省略了public关键词
  constructor(name:string) { // 构造函数  实例化类的时候触发的方法
    this.name = name
  }
	getName():string{
    return this.name;
  }
	setName(name:string):void{
    return this.name = name;
  }
}
// 实例化：
var p = new Person('张三');
p.getName(); // 张三
p.setName('李四');
p.getName(); // 李四

3.4.3 ts中实现继承 extends / super

class Person{
  name:string;
  constructor(name:string) {
    this.name = name;
  }
  run():string{
    return `${this.name}在运动`;
  }
}
class Web extends Person{
  constructor(name:string) {
    super(name); //super调用父类的构造函数 实现继承
  }
}
var w = new Web('李四')；
w.run();
## 如果子类和父类的方法相同，输出子类的方法。一般都是从子类找方法，如果没有在到父类中找方法。

3.4.4 ts类里面的修饰符 ts中定义属性的时候提供了三种修饰符

public : 共有， 在当前类里面，子类，类外面都可以访问

protected ：保护类型 在当前类里面，子类里面可以访问，外部无法访问

private ：私有的，在当前类里面可以访问，子类，类外部无法访问。

属性不添加修饰符默认是public

class Person{
  public name:string;
  constructor(name:string) {
    this.name = name;
  }
  run():string{
    return `${this.name}在运动`;
  }
}
class Web extends Person{
  constructor(name:string) {
    super(name); // 子类可以访问
  }
}
var w = new Web('李四')；
w.run();

3.4.5 静态属性，静态方法

es5中的静态方法：

function Person() {
  this.run1 = function() { // 实例方法
    xxx
  }
}
Person.run2 = function() { // 静态方法
  xxx
}
// 调用：
var p = new Person();
p.run1();

Person.run2(); // 静态方法的调用 

ts中的静态属性和方法

class Person{
  public name:string;
  static sex = '男'
  constructor(name:string) {
    this.name = name;
  }
  run():string{ // 实例方法
    return `${this.name}在运动`;
  }
  work() {
    alert(`${this.name}在工作`);
  }
  // 静态方法：
  static print() {
    alert(`print方法`);
    // 静态方法里面没法直接调用类里面的属性，可以设置静态属性
    alert(`${this.sex}`);
  }
}

// 静态方法的调用：
Person.print();
Person.sex;

3.4.6 ts中的多态：父类定义一个方法不去实现，让其继承它的子类去实现，每一个子类有不同的表现

多态属于继承

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+'吃老鼠';
  }
}

3.4.7 抽象方法 它提供其他类继承的基类，不能被直接实例化。

用abstruct关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

abstruct抽象方法只能放在抽象类里

抽象类和抽象方法用来定义标准

eg:抽象类和抽象方法用来定义标准，标准：Animal 这个类要求它的子类必须包含eat方法

抽象方法实现抽象类

// 是一个被其他类继承的基类，子类必须要实现抽象类中的方法
abstract class Animal{
  public name:string;
  constructor(name:string) {
    this.name = name;
  }
  abstruct eat():any;
}

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