typescript类

//4.1定义类
class Person{
    name:string;
    constructor(n:string){
        this.name = n;
    }
    getName():string{
        return this.name
    }

    setName(name:string):void{
        this.name = name;
    }
}
const p = new Person('qin');
p.setName('kai');

//实现继承
class Web extends Person{
    constructor(name:string){
        super(name)
    }
}
var w = new Web('li');
w.getName()

//4.2类里的修饰符（ts定义属性时给我们提供了3种修饰符）
// public： 公有，        在类里面，，子类，类外面都可以访问
// protected: 保护类型，  在类里面，子类可以访问，类外部不能访问；
// private:私有，        在类里面可以访问，子类和类外面都不能访问；
//属性如果不加修饰符，默认为公有



//静态方法与实例方法

// function Person2(){
//     this.sum = function(){     //实例方法
//         console.log(123)
//     }
// }

// Person2.run = function(){        //静态方法
//     console.log(234)
// }
// Person2.name='aah'   //静态属性

// let  p2 = new Person2();
// p2.sum();
// Person2.run()
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 scale
let grid2 = new Grid(5.0);  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));


//多态：父类定义一个方法不去实现，让继承他的子类去实现，每一个子类有不同的表现
//多态属于继承



//抽象：抽象类和抽象方法用来定义标准，这个类要求他的子类必须包含他的方法，抽象方法不包含具体实现并且必须在派生类中实现。
//ts中的抽象类，只是提供其他类型继承的基类，不能直接被实力化。
abstract class Animal{  //抽象类
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    abstract eat():any;
}
//let a = new Animal();//这时错误写法，抽象类不能被实例化。
class Dog extends Animal{
    constructor(name:any){
        super(name)
    }
    eat(){
        console.log(this.name)
    }
}