TypeScript | 第二章：类、接口和之间的关系

class Dog{  constructor(name:string){        this.name = name;    }    name:string //成员属性添加类型注解  run(){}  //挂载到Dog.prototype上}

class Husky extends Dog{    constructor(name:string,color:string){        super(name) //强制规定，代表父类的实例        this.color = this.color;    }    color:string}

class Dog1{    //类不能被实例化、也不能被继承    private constructor(public color:string){//color变成实例属性
    }    //public:公有，默认，对所有可见    public name:string    //private:私有，类本身访问，不能被类的实例/子类访问    private pri(){}    //protected:受保护成员，只能在类和子类访问，不能被实例访问    protected pro(){}    //只读属性，不可被更改，要赋初始值    readonly legs:number = 4    //静态成员:只能通过类名来调用，不能通过实例调用，可以被子类继承    static food:string = 'bones'}

class WorkFlow {    constructor() {            }    step1(){        return this    }    step2(){        return this    }}
// 返回this，实现了方法链式调用new WorkFlow().step1().step2();

//继承的时候this表现出多态，可能是父类或者子类class MyFlow extends WorkFlow{  next(){      return this; //返回子类类型  }}//           子类-->父类new MyFlow().next().step1().next().step2();

let passcode = "secret passcode";
class Employee {    private _fullName: string;
    get fullName(): string {        return this._fullName;    }
    set fullName(newName: string) {          // 当密码不对，则无法修改        if (passcode && passcode == "secret passcode") {            this._fullName = newName;        }        else {            console.log("Error: Unauthorized update of employee!");        }    }}
let employee = new Employee();employee.fullName = "Bob Smith";if (employee.fullName) {    alert(employee.fullName);}

class Grid {    static origin = {x: 0, y: 0};    calculateDistanceFromOrigin(point: {x: number; y: number;}) {        let xDist = (point.x - Grid.origin.x);        let yDist = (point.y - Grid.origin.y);        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;    }    constructor (public scale: number) { }}
let grid1 = new Grid(1.0);  // 1x scalelet grid2 = new Grid(5.0);  // 5x scale

abstract class Animal {    constructor() {            }    eat(){}    //抽象方法：不指定具体的实现,明确知道子类有具体的实现    abstract sleep():void}//new Animal() 报错：不能被实例

class Cat extends Animal {    constructor(name:string) {        super()        this.name=name    }    name:string    run(){}    sleep(){        console.log('cat is sleep')    }}
class Pig extends Animal{    constructor() {        super();    }    sleep(){console.log('pig is sleep')}}
//多态let animals:Animal[] = [new Cat('1'),new Pig()];animals.forEach(i=>{    i.sleep();})

interface Label{  name:string;}
// Label接口，用来描述入参的要求// 类型检查器会查看printLabel的调用，并要求入参必须包含一个name属性，且类型为string// 编译器只会检查那些必须的属性是否存在，并且类型是否匹配，然后有时候并不那么宽松，但可以使用类型断言function printLabel(label:Label){  console.log(label.name)}
let obj = {name:'张三',age:23}printLabel(obj)

interface SquareConfig{	color?:string;  // '?'表示可选属性，接口里的属性不全都是必需的  width?:number;}
function createSquare(config:SquareConfig): {color: string; area: number} {	let newSquare = {color: "white", area: 100};  if (config.col) {     // 好处2：捕获不存在的属性错误  Error:propery 'col' does not exit on type 'SquareConfig'    newSquare.color = config.color;  }  if (config.width) {    newSquare.area = config.width * config.width;  }  return newSquare;}
let mySquare = createSquare({color: "black"});

interface Point{  readonly x:number}
let p:Point = {x:10} // 刚创建的时候修改值p.x = 1;   // 报错
// 数组只读类型：ReadonlyArray<T>let arr:number[] = [1,2]let ro:ReadonlyArray<number> = arr; // ro只读ro[0] = 2;  // 报错ro.push(3)  // 报错ro.length   // 报错let a = ro  // 报错  --> 类型断言重写 let a = ro as number[]; // 正确

// 借用2. 可选属性的例子let s1 = createSquare({clor: "black"}); // 报错:'clor' not expected in type 'SquareConfig'
// 最简单的方法: 绕开这些检查使用类型断言：let s2 = createSquare({clor: "black",color: "black",width:10} as SquareConfig)
// 最佳的方式：添加一个字符串索引签名，前提确定对象存在额外用途属性interface SquareConfig{	color?:string,  width?:number,  [propName:string]:any  // 字符串索引签名}
// 惊人的方式：将入参对象赋值给另一个对象let squareOptions = { colour: "red", width: 100 }; // 赋值给另一个对象let mySquare = createSquare(squareOptions);    // squareOptions不会经过额外属性检查

interface SearchFunc {  (source: string, subString: string): boolean;}
let mySearch: SearchFunc;// 函数的参数名不需要与接口定义的名字相匹配，但要求对对应位置上的参数类型是兼容的// 若参数名不指定类型，ts类型系统会自行推断// 函数返回值，根据接口定义的函数类型返回值推断mySearch = function(s: string, sub: string) {  let result = source.search(subString);  return result > -1;}

interface StringArray{	[index:number]:string // [index:number] 数字索引  :string索引返回类型}
// 数字索引let myArray: StringArray;myArray = ["Bob", "Fred"];let myStr: string = myArray[0];

class Animal{  name:string,}class Cat extends Animal{	age:string}// 字符串索引interface{  [name:string]:Animal}
// 字符串索引签名能够很好的描述dictionary模式interface NumberDictionary{	[index:string]:number     // 返回值为number类型的字典}
// 防止给索引赋值，索引签名设置为只读interface ReadonlyStringArray{	readonly [index:number]:string}let arr:ReadonlyStringArray = ['1','2']arr[2] = '3' ;  // 报错，索引是只读的

interface Human{    name:string,    eat():void}
//类实现接口，必须实现接口中声明的所有属性//接口只能约束类的公有成员class Asia implements Human{    constructor(name:string){        this.name = name;    }    name:string    eat(){}    sleep(){
    }}

/** * 接口的继承 * 接口可以像类一样继承，一个接口可以继承多个接口*/interface Man extends Human{    run():void}
interface Child{    cry():void}
interface Boy extends Man,Child{}
let body:Boy = {    name:'',    run(){},    eat(){},    cry(){}}

/** * 接口继承类 * 相当于接口把类的成员都抽象出来，只有类的成员接口，没有具体的实现*/class Auto{    state = 1;    //2. 接口抽离类的成员，不仅抽离公共成员，还抽离私有成员和受保护成员    //private state2 = 0;}
//接口中，隐含了state属性interface AutoInterface extends Auto{
}
//实现接口，只要类的成员存在state属性即可class C implements AutoInterface{    state = 2;    //若Auto配置了私有成员，此处报错，因为C不是Auto的子类，自然不能包含其它的非公有成员}
//Auto子类也可以实现AutoInterface这个接口class Bus extends Auto implements AutoInterface{    //不必实现state属性，auto的子类，自然继承了state属性}