typescrip(5)中的类 类的定义，继承，类里面的修饰符

目录：
typeScript 中的类
1、类的定义
2、继承
3、类里面的修饰符
4、静态属性 静态方法
5、抽象类 继承多态

【1】ts中定义类

class Person{
    name:string;//属性， 前面省略了public 关键词
    constructor(n:string){//构建函数， 实例化类的时候触发的方法
        this.name = n;
    }

    run():void{
        alert(this.name);
    }
}
var p = new Person('jack');
console.log(p.name);
p.run();

栗子

class Person{
     name:string;
     constructor(name:string){
         this.name = name;
     }
     getName():string{
         return this.name;
     }
     setName(name:string):void{
         this.name = name;
     }
 }

 var p = new Person('jack');
 console.log(p.name);
 alert(p.getName());
 p.setName('lily');
 console.log(p.name);
 alert(p.getName());

【2】ts中的继承，extends 、super

class Person{
    name:string;
    constructor(name:string){
        this.name = name;
    }
    getName():string{
        return this.name;
    }
    setName(name:string):void{
        this.name = name;
    }

}
class Web extends Person{//用到了extends 、super
    constructor(name:string){
        super(name);
    }
   
}
var w = new Web('jack');
console.log(w.name);
alert(w.getName());
w.setName('lily');
alert(w.getName());

ts中继承的探讨，父类和方法和子类的方法一致

class Web extends Person{//用到了extends 、super
    constructor(name:string){
        super(name);//初始化父类的构造函数
    }
    work(){//Web可以设置自己的方法
        console.log('hhhhhhh'+this.name);
    }
    getName():string{//如果子类的方法和父类同名，子类的方法会覆盖父类的方法
        return `${this.name}----我是子类的方法`;
    }
}
var w = new Web('jack');
w.work();
console.log(w.name);
alert(w.getName());
w.setName('lily');
alert(w.getName());

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

• public:公有 在类里面、子类、类外面都可以访问。
• protected: 保护类型 在类里面、子类里面可以访问，在类外部没法访问。
• private: 私有 在类里面可以访问，子类，类外部都没法访问。

【public】公有 在类里面、子类、类外面都可以访问。

class Person{
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    getName():string{
        return `${this.name}`;//(1)在类里面获取name
    }
}
var p = new Person('jude');
//(2)在类的外面获取name
console.log(p.name);
alert(p.getName());


//创建子类
class Son extends Person{
    constructor(name:string){
        super(name)
    }
}
var s = new Son('jack');
//(3)在子类里获取name
console.log(s.name);
alert(s.getName());

【protected】 保护类型 在类里面、子类里面可以访问，在类外部没法访问。
class Person{
protected age:number;
protected name:string;
constructor(age:number,name:string){
this.age=age;
this.name = name;
}
getMes():string{
return ${this.name} said，his age was ${this.age}//(1)在类里面可以获取到name 和age
}
}

class Son extends Person{
    constructor(age:number,name:string){
        super(age,name);
    }
    getName():string{
        return this.name;//(2)可以获取到父类的name
    }
    getAge():string{
        return `this.age`;//(2)可以获取到父类的age
    }
}
var s = new Son(19,'jack');
//console.log(s.name);
//console.log(s.age);//(3)在类的外面获取name，会在终端报错
console.log(s.getName());
console.log(s.getAge());




var p = new Person(18,'jude');
// console.log(p.name);
console.log(p.getMes());
//console.log(p.age);//(3)在类的外面获取name，会在终端报错

【private】私有 在类里面可以访问，子类，类外部都没法访问。

 class Person{
     private name:string;
     constructor(name:string){
         this.name = name;
     }
     getName():string{
         return `我的名字是${this.name}`//(1)在当前子类中可以获取到
     }
 }
 var p = new Person('jude');
 console.log(p.name);//(2)终端会报错,在外部会报错，获取不到
 console.log(p.getName());

 class Son extends Person{
     constructor(name:string){
         super(name);
     }
     getName():string{
         return `我的新名字是：${this.name}`;//(3)终端会报错，在子类中无法获取到父类的name ,因为用了private
     }
 }

静态属性 静态方法 抽象类 继承多态 将在下一节讲解。