TypeScript及React学习系列三：typescript中的类（下）

typescript中的类

• ts类的定义
• ts中实现继承
• 类中的修饰符
• 静态属性与静态方法
• 多态
• 抽象方法和抽象类

1. 类的定义

使用class关键字

class Person{
	name:string; //定义属性，前面省略了public
	constrctor(n:string){//构造函数，实例化类的时候会触发
		this.name = n;
	}
	getName():string{
		return this.name;
	}
	setName(name:string):void{
		this.name = name;
	}
}
let p = new Person("李华");
alert(p.getName()); //打印李华

2. ts中实现继承

使用extends、super关键字

class Person{
...//内容与上例相同
}
class Student ectends Person{
	constructor(name:string){
		super(name); //初始化父类的构造函数
	}
}

子类除了可以继承父类的属性和方法，还可以扩展自己的方法

class Person{
...//内容与上例相同
}
class Student ectends Person{
	constructor(name:string){
		super(name); //初始化父类的构造函数
	}
	work():void{ //扩展自身的方法
		alert(`${this.name}在工作`);//打印，李华在工作
	}
}

如果字类和父类方法名一样，优先调用字类的方法

class Person{
	name:string; //定义属性，前面省略了public
	constrctor(n:string){//构造函数，实例化类的时候会触发
		this.name = n;
	}
	study():string{
		return `${this.name}在运动`;
	}
}
let p = new Person("李华");
class Student ectends Person{
	constructor(name:string){
		super(name); //初始化父类的构造函数
	}
	study():void{
		alert(`${this.name}在学习`);
	}
}
let s = new Student("张三");
s.study(); //打印，张三在学习

3. 类中的修饰符

typescript中提供了三种属性修饰符，public，protected，private

• public : 公有，在当前类里、子类、类外都可访问
• protected ：保护类型，当前类里、子类可以访问，类外不可访问
• private ：私有，当前类里可访问，子类和类外不可访问

public	类里、子类、类外
protected	类里、子类
private	类里

注：如果不加修饰符，则默认为共有public

class Person{
	name:string; //定义属性，默认为public
	constrctor(n:string){//构造函数，实例化类的时候会触发
		this.name = n;
	}
	study():string{
		return `${this.name}在运动`;
	}
}
let p = new Person("李华");
alert(p.name); //当前类访问公有属性

4. 静态属性与静态方法

通过static声明的方法为静态方法，可以直接通过 “类名.方法” 来调用静态方法

class Person{
	public name:string
	public age:number
	constructor(name:string){
		this.name = name;
	}
	study(){ //实例方法，需实例化后才可使用
		alert(`${this.name}在学习`);
	}
	static run(){ //静态方法
		alert(`${this.name}在运动`);
		alert(this.age); //报错，无法在静态方法中直接调用类里的属性
	}
}
Person.run(); //调用静态方法

注：无法在静态方法里直接调用类里的属性

通过static声明的属性为静态属性，可以直接调用

class Person{
	public name:string
	static age:number
	constructor(name:string){
		this.name = name;
	}
	study(){ //实例方法，需实例化后才可使用
		alert(`${this.name}在学习`);
	}
	static run(){ //静态方法
		alert(`${this.name}在运动`);
		alert(this.age); //正确
	}
}
Person.run(); //调用静态方法
alert(Person.age); //正确

5. 多态

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

class Animal{
    public 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 + "吃猫粮"
    }
}

6. 抽象方法和抽象类

typescript中的抽象类：是提供其他类继承的基类，不能直接实例化；
用abstract关键字来定义抽象方法和抽象类；
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现；
abstract抽象方法只能放在抽象类里；
抽象类和抽象方法用来定义标准；
抽象方法必须在派生类中实现，普通方法可以不实现；

abstract class Animal{//抽象类
    public name : string;
    constructor(name : string){
        this.name = name;
    }
    abstract eat():any; //抽象方法，在派生类中必须实现
    run(){  //普通方法，在派生类中可以不实现
        console.log("跑步");
    }
}

class Dog extends Animal{
    constructor(name:any){
        super(name)
    }
    eat(){
        return this.name + "吃狗粮";
    }
}

class Cat extends Animal{
    constructor(name:any) {
        super(name)
    }
    eat(){
        return this.name + "吃猫粮";
    }
}

let d = new Dog("小黑");
let c = new Cat("加菲");
d.eat(); //小黑吃狗粮
c.eat(); //加菲吃猫粮