類

類描述了所創(chuàng)建的對象共同的屬性和方法。
使用關鍵字 class 聲明，后面緊跟類名，類可以包含以下幾個模塊（類的數據成員)
字段 ? 字段是類里面聲明的變量。字段表示對象的有關數據。
構造函數 ? 類實例化時調用，可以為類的對象分配內存。
方法 ? 方法為對象要執(zhí)行的操作。

• public修飾的屬性或者方法是共有的, 可以在任何地方被訪問到, 默認所有的屬性或者都是public的
• private修飾的屬性或者方法是私有的, 不能在聲明它的類外面訪問, 只能在類的內部進行訪問
• protected修飾的屬性或者方法是受保護的, 它和private類似, 外部是不可以訪問的, 在類的內部和子類的內部是可以訪問的

class Person {
   private name='張三'
   age=19
   protected sex: string='男'
   say(a: number): string{
       return('名字:'+this.name+'年齡:'+this.age+a) 
   }
}
// 創(chuàng)建Person的實例
var p = new Person()
console.log(p.say(2))
====>>  名字:張三年齡:192

• 構造函數constructor
• 多個對象具有共同屬性, 面對不同對象實例化的時候在去賦值 使用構造函數
• constructor一般在實例化的時候執(zhí)行, new一次就會執(zhí)行一次

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

    /**
     * 構造函數constructor
     * 多個對象具有共同屬性, 面對不同對象實例化的時候在去賦值 使用構造函數constructor
     *  constructor一般在實例化的時候執(zhí)行, new一次就會執(zhí)行一次
     */
    constructor(name: string, age: number){
        console.log('執(zhí)行構造函數')
        this.name = name
        this.age = age
    }
}

const p1 = new Person('姓名', 18)
const p2 = new Person('姓名2', 19)
console.log(p1, p1)
====>>  執(zhí)行構造函數
====>>  執(zhí)行構造函數
====>>  Person { name: '姓名', age: 18 } Person { name: '姓名', age: 18 }

• 類的繼承 extends
• 子類除了不能繼承父類的私有成員(方法和屬性)和構造函數，其他的都可以繼承。
• 一次只能繼承一個類，不支持繼承多個類，但支持多重繼承（A 繼承 B，B 繼承 C）。
• 在實現繼承時，子類構造函數中必須調用 super 方法，super 關鍵字是對父類的直接引用，該關鍵字可以引用父類的屬性和方法。
• abstract: 抽像類 使用abstract修飾的類只能做為其他類繼承的父類, 不能直接被實例化
• 使用 abstract 關鍵字定義抽象類和抽象方法，抽象類中的抽象方法不能直接實現并且必須在子類中實現。抽象方法必須放在抽象類中使用
• static 關鍵字用于定義類的數據成員（屬性和方法）為靜態(tài)的，靜態(tài)成員可以直接通過類名調用

abstract class Animal {
   name: string
   static age: number // 類的靜態(tài)方法里面, 是不允許用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('靜態(tài)方法')
   }
}

Animal.work()   
====>> 靜態(tài)方法

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就不會執(zhí)行, 需要使用super重定義調用, 即可以在子類當中在執(zhí)行一次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 聲明

• 接口是一系列抽象方法的聲明，是一些方法特征的集合，這些方法都應該是抽象的，需要由具體的類去實現，然后通過這組抽象方法調用，讓具體的類執(zhí)行具體的方法。
• 在面向對象的編程中，接口是一種規(guī)范的定義，它定義了行為和動作的規(guī)范。在程序設計里，它起到了一種限制和規(guī)范的作用
• 兩個接口同名可以進行聲明合并

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: '男' }

• 動態(tài)添加屬性

interface Istate {
    name: string
    age?: number
    [propName: string]: any  // 動態(tài)添加屬性
}
var obj3: Istate = {name: '張', age: 10, sex: '男', isMa: true }

• 只讀屬性

interface Istate4 {
    name: string
    readonly age: number  // 用readonly修飾就變?yōu)橹蛔x屬性, 賦初始值之后就不能在進行更改
}
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
}
// 創(chuàng)建類使用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 ')