Typescript：类

1.类的定义

class Person {
    name: String;//属性不加修饰符时，默认是public的
    age: number;
    //构造方法 与java不同，不是使用类名，而是使用constructor
    constructor(name: String, age: number) {
        this.name = name;
        this.age = age;
    }
    //方法，不用加function关键字
    say() {
        return `Hello，my name is ${this.name},I'm ${this.age} years old`;
    }
}
var person = new Person("yzq", 23);
alert(person.say());

2.继承

class Student extends Person{
    school:String;
    constructor(){
        super("yzq",23);//调用父类构造函数
        this.school="清华"
    }
    /*这个地方类似 重写 */
    say(){
        return `姓名:${this.name},年龄${this.age},学校${this.school}`
    }
}

3.访问修饰符

跟java类似，TypeScript的访问修饰符有三个，分别是public、private、protected 。
TypeScript的默认访问修饰符是public。
1）public声明的属性和方法在类的内部和外部均能访问到。
2）protected声明的方法和属性只能在类的内部和其子类能访问。

3）private声明的方法和属性只能在其类的内部访问。

4.readonly修饰符

使用readonly关键字会将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。且值不能不能被修改，和const类似。

class Person { 
    readonly name: string;
    readonly age: number=23;//必须初始化
    constructor(name:string) {
        this.name = name;//必须初始化
   }
}
let p = new Person("yzq");
p.name = "aaa"//错误，不能被修改
p.age=24//错误，不能被修改

6.存取器（Getter And Setter）

TypeScript中的存取器就类似与java中set和get方法，只不过调用的方式不一样。比如在一个类中我们将其中一个属性用private修饰，那么，在类的外部就无法访问到该属性，这个时候我们可以通过getters/setters来封装一下，以便在类的外部去访问该属性。

class Person {
    private age: number;
    get age() {
        return this._age;
    }
    set age(inputAge: number) {
        /*这里可以做一些逻辑处理 */
        if (inputAge < 0 || inputAge > 150) {
            alert("年龄异常");
        } else {
            this._age = inputAge;
        }
    }}

7.静态方法

静态属性直接通过类名访问，无需实例化。用static修饰的属性会在这个类被加载的时候就进行初始化。

（1）es5中静态方法定义（直接在构造函数上定义）：

Person.talk=function(){
}

（2）TypeScript在方法名前加上static，静态方法不能访问类里面的非静态属性，只能访问类里面的静态属性

class Person {
    static name: String; 
    static age: number;
    constructor(name: String, age: number)
         { this.name = name; this.age = age; }
     static say() {
             return “Hello，my name is”+Person.name+“,I'm ”+Person.age+“years old”;
           }
}

8.多态类

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

              class Animal {//父类
                    name:string;
                    constructor(name:string) {
                        this.name=name;
                    }
                    eat(){   //具体吃什么  不知道   ，  具体吃什么?继承它的子类去实现 ，每一个子类的表现不一样
                        console.log('吃的方法')
                    }
                }
                class Dog extends Animal{//子类
                    constructor(name:string){
                        super(name)
                    }
                    eat(){
                
                        return this.name+'吃粮食'
                    }
                }
                class Cat extends Animal{//子类
                    constructor(name:string){
                        super(name)
                    }
                    eat(){
                        return this.name+'吃老鼠'
                    }
                }

8.抽象

用abstract关键字定义抽象类和抽象方法，抽象方法只能存在于抽象类中，不包含具体实现{...}

abstract class Animal{ 
    public name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract eat():any;  //抽象方法不包含具体实现并且必须在子类中实现。
    run(){
        console.log('其他方法可以不实现')     //抽象类中可以有非抽象方法
    }
}
// var a=new Animal() /*错误的写法，抽象类不能被实例化，只能用作其他类的基类*/

class Dog extends Animal{
    constructor(name:any){
        super(name)
    }
 //抽象类的子类必须实现抽象类里面的抽象方法
    eat(){
        console.log(this.name+'吃粮食')
    }
}
var d=new Dog('小狗');
d.eat();

猜你喜欢