typeScript中类和接口的使用

类

类描述了所创建的对象共同的属性和方法。
使用关键字 class 声明，后面紧跟类名，类可以包含以下几个模块（类的数据成员)
字段 − 字段是类里面声明的变量。字段表示对象的有关数据。
构造函数 − 类实例化时调用，可以为类的对象分配内存。
方法 − 方法为对象要执行的操作。

• public修饰的属性或者方法是共有的, 可以在任何地方被访问到, 默认所有的属性或者都是public的
• private修饰的属性或者方法是私有的, 不能在声明它的类外面访问, 只能在类的内部进行访问
• protected修饰的属性或者方法是受保护的, 它和private类似, 外部是不可以访问的, 在类的内部和子类的内部是可以访问的

class Person {
   private name='张三'
   age=19
   protected sex: string='男'
   say(a: number): string{
       return('名字:'+this.name+'年龄:'+this.age+a) 
   }
}
// 创建Person的实例
var p = new Person()
console.log(p.say(2))
====>>  名字:张三年龄:192

• 构造函数constructor
• 多个对象具有共同属性, 面对不同对象实例化的时候在去赋值 使用构造函数
• constructor一般在实例化的时候执行, new一次就会执行一次

class Person {
    // 字段
    name: string
    age: number

    /**
     * 构造函数constructor
     * 多个对象具有共同属性, 面对不同对象实例化的时候在去赋值 使用构造函数constructor
     *  constructor一般在实例化的时候执行, new一次就会执行一次
     */
    constructor(name: string, age: number){
        console.log('执行构造函数')
        this.name = name
        this.age = age
    }
}

const p1 = new Person('姓名', 18)
const p2 = new Person('姓名2', 19)
console.log(p1, p1)
====>>  执行构造函数
====>>  执行构造函数
====>>  Person { name: '姓名', age: 18 } Person { name: '姓名', age: 18 }

• 类的继承 extends
• 子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
• 一次只能继承一个类，不支持继承多个类，但支持多重继承（A 继承 B，B 继承 C）。
• 在实现继承时，子类构造函数中必须调用 super 方法，super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法。
• abstract: 抽像类 使用abstract修饰的类只能做为其他类继承的父类, 不能直接被实例化
• 使用 abstract 关键字定义抽象类和抽象方法，抽象类中的抽象方法不能直接实现并且必须在子类中实现。抽象方法必须放在抽象类中使用
• static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用

abstract class Animal {
   name: string
   static age: number // 类的静态方法里面, 是不允许用this, 只能使用类名访问
   constructor(name: string, age: number) {
       this.name = name
       Animal.age = age
   }    

   // abstract move(distance: number): void // 抽象方法, 只能为子类重新定义的方法, 抽像方法只能在抽象类中使用
   move(distance: number, sex: string) {
       console.log(`${this.name} 跑了 ${distance}M, ${sex},, ${Animal.age}`);
   } 

   // 抽象方法
   abstract eat(): void

   static work(): void{
       console.log('静态方法')
   }
}

Animal.work()   
====>> 静态方法

class Dog extends Animal {
   move(distance: number) {
       console.log('正在跑…', distance, '-000-----', this.name)
       super.move(distance, '123')
   }

   eat(): void{
       console.log(`${this.name}正在吃`);
       
   }
}

class Snake extends Animal {

   // 子类的构造函数必须包含super调用
   // 子类中定义相当于是对父类的取代, 父类当中的constructor就不会执行, 需要使用super重定义调用, 即可以在子类当中在执行一次constructor
   constructor(name: string) {
       super(name, 30)
       console.log('211111', this.name)
   }

   eat(): void{
       console.log(`${this.name}正在吃`);
       
   }
}

const dog = new Dog('老', 20)
const snake = new Snake('小')

dog.move(50)
dog.eat()
snake.move(19, 'll')
snake.eat()

====>> 
211111 小
正在跑… 50 -000----- 老
老 跑了 50M, 123,, 30
老正在吃
小 跑了 19M, ll,, 30
小正在吃

接口

使用关键字interface 声明

• 接口是一系列抽象方法的声明，是一些方法特征的集合，这些方法都应该是抽象的，需要由具体的类去实现，然后通过这组抽象方法调用，让具体的类执行具体的方法。
• 在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范。在程序设计里，它起到了一种限制和规范的作用
• 两个接口同名可以进行声明合并

interface User {
    name: string
    age: number
}
/**
 * 接口可以继承接口 
 */
interface InUser extends User {
    sex: string
}

const obj: InUser ={
    name: '姓名',
    age: 20,
    sex: '男'
}

console.log(obj);
====>>  { name: '姓名', age: 20, sex: '男' }

• 动态添加属性

interface Istate {
    name: string
    age?: number
    [propName: string]: any  // 动态添加属性
}
var obj3: Istate = {name: '张', age: 10, sex: '男', isMa: true }

• 只读属性

interface Istate4 {
    name: string
    readonly age: number  // 用readonly修饰就变为只读属性, 赋初始值之后就不能在进行更改
}
var obj4: Istate4 = {name: '张', age: 10}
obj4.name = '李'
// obj4.age = 20  // 不支持更改

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

interface Iencrypt {
    (key: string, value: string): string
}
const encry: Iencrypt = function(key: string, value: string): string{
    return key + '=' + value
}

console.log('函数类型接口', encry('name', 'star'))
====>>  函数类型接口 name=star

• 可索引接口
• 可索引接口一般用于对数组和对象的约束。

interface IFoo {
   [index: number]: string    // 表示了当用 number去索引fooArr时会得到string类型的返回值。
}
const fooArr: IFoo = ['ww', 'ee', 'ss']
console.log(fooArr[0])
====>>  ww

• 类类型接口
• 类类型接口是对类的约束，它是对属性接口和函数型接口的结合

interface Myinter {
    name: string
    move(): number
}
// 创建类使用implements限定接口类型
class MyClass implements Myinter {
    name: string  // 必须包含Myinter中的属性和方法
    age: number
    // 必须进行constructor初始化
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
    move(): number{
        return 11
    }
}
const cla = new MyClass('name', 1)
console.log('类类型接口', cla.move());
====>>  类类型接口 11


interface Ieat {
    eat(food: string):void
}

interface Irun{
    run(distance: number):void
}
class Per implements Ieat, Irun {
    eat(food: string): void{
        console.log(`eat: ${food}`)
    }
    run(distance: number) {
        console.log(`run: ${distance}`)
    }
}

class Animal1 implements Ieat, Irun {
    eat(food: string): void{
        console.log(`eat: ${food}`)
    }
    run(distance: number) {
        console.log(`run ${distance}`)
    }
}

const a1 = new Per()
a1.eat('i lk gyt ')