typeScript中的类（四）

定义类

class Person{
     name:string;   //属性：省略了public关键字
     constructor(n:string){  //构造函数，实例化类的时候触发方法
         this.name=n
     }
     run():string{
         return this.name
     }
}
var p = new Person('zhangsan');
 p.run()

class Person{
     name:string;   //属性：省略了public关键字
     constructor(name:string){  //构造函数，实例化类的时候触发方法
         this.name=name
     }
     run():string{
         return this.name
     }
     getName():void{
         console.log(this.name)
         alert(this.name)
     }
     setName(name:string):void{
         this.name=name;
     }
}
var p = new Person('zhangsan');
p.getName()   //zhangsan
p.setName('lisi')
p.getName()   //lisi

继承

class Person{
    name:string;
    constructor(name:string){
        this.name=name;
    }
    run():void{
        alert(this.name+'写作业')
    }
}

class web extends Person{
    constructor(name:string){
        super(name);
    }
    //注意：若子类的方法属性名与父类一样，会执行子类的方法和属性
}

var w = new web('zhangsan')
w.run();

修饰符

typescript里面定义属性的时候给我们提供了三种修饰符

public:共有 在类里面、子类、类外面都可以访问

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

private:私有 在类里面可以访问，子类、类外部无法访问

属性如果不加修饰符，默认就是共有

//protected：保护类型
class Person{
    protected name:string;   
    constructor(name:string){
        this.name=name
    }
    work():void{
        alert(this.name+'在做项目策划')
    }
}
var p = new Person('lisi');
p.work();
console.log(p.name)   //类外部访问不到
class web extends Person{
    constructor(name:string){
        super(name)
    }
    game():void{
        alert(this.name+'在做游戏')
    }
}
var w = new web('zhangsan')
w.game();

//private:私有类
class Person{
    private name:string;   
    constructor(name:string){
        this.name=name
    }
    work():void{
        alert(this.name+'在做项目策划')
    }
}
var p = new Person('lisi');
p.work();
console.log(p.name)   //类外部访问不到
class web extends Person{
    constructor(name:string){
        super(name)
    }
    game():void{   
        alert(this.name+'在做游戏')   //子类访问不到name
    }
}
var w = new web('zhangsan')
w.game();

class Octopus {
    readonly name: string;    //只读属性,只读的约束存在于第一次给对象赋值的时候，而不是第一次给只读属性赋值的时候
    readonly numberOfLegs: number = 8;
    constructor (name: string) {
        this.name = name;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit";     //cannot assign to 'name' because it is a read-only property----name 是只读的.
dad.numberOfLegs     //8

参数属性

class Animal {
     //在构造函数里使用private name: string参数来创建和初始化name成员
    constructor(private name: string) { }    //子类，类外部无法访问
    move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}
var a = new Animal('小米')
//console.log(a.name)   //报错，属性为private name为私有属性，只能在Animal中使用

存取器

存取器要求将编译器设置为输出ECMAScript 5或更高。 不支持降级到ECMAScript 3。 其次，只带有get不带有set的存取器自动被推断为readonly

let passcode = 'secret passcode'
class Employee{
    private _fullName:string;
    constructor(name:string){
        this._fullName=name
    }
    get fullName():string{
        console.log(this._fullName)
        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('zhang');
employee.fullName   //zhang
employee.fullName='boom'
employee.fullName   //boom

静态属性、静态方法

class Person{
    public name:string;
    static sex:string = '女'
    constructor(name:string){
        this.name=name
    }
    work():void{
        alert(this.name+'正在努力工作')
    }
    static run(name:string){  //静态方法无法调用类里面的属性
      alert(`${name}是${Person.sex}同学`);
    }
}
var p = new Person('zhangxiaomei')
p.work();
Person.run('王小二');

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

class Animal{
    public name:string;
    constructor(name:string){
        this.name=name
    }
    eat(){
        console.log(name)
    }
}
class dog extends Animal{
    constructor(name:string){
        super(name)
    }
    eat():string{
        return this.name+'吃肉'
    }
}
class cat extends Animal{
    constructor(name:string){
        super(name)
    }
    eat():string{
        return this.name+'吃鱼'
    }
}
var d = new dog('狗')
var c = new cat('猫咪')
alert(d.eat());
alert(c.eat());

抽象类

typescript中的抽象类：它是提供其他类继承的基类，不能直接被实例化

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

abstratct抽象方法只能放在抽象类里面

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

abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name=name
    }
    abstract eat():any;
}
class Dog extends Animal{
    constructor(name:string){
        super(name)
    }
    eat(){
        alert(this.name+'吃肉肉')
    }
}
var dog = new Dog('狗狗');
dog.eat();

class Cat extends Animal{
    constructor(name:string){
        super(name)
    }
    eat(){
        alert(this.name+'吃鱼')
    }
}
var cat = new Cat('猫咪');
cat.eat();