typeScript知识点之类的定义和使用

前言

原来typescript中还有类。简直跟java一毛一样了。。类中可以定义属性，可以定义方法而且还有继承、多态，学会java的应该比较容易理解吧

类的基本定义

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('张三');
alert(p.getName());
p.setName('李四');
alert(p.getName());

类的继承

子类可以调用父类的方法和属性

如果子类中有和父类相同的方法，表示重写父类的方法，调用该方法是会调用之类中的该方法

class Person{
    name:string;
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
class Web extends Person{
    constructor(name:string){
        super(name);  /*初始化父类的构造函数*/
    }
}
var w=new Web('李四');
alert(w.run());

类修饰符

类中还有修饰符。不用的修饰符，可访问的范围不同

1. public :公有 ，在当前类里面、 子类 、类外面都可以访问（如果类前面不写，默认表示public）
2. protected：保护类型 ，在当前类里面、子类里面可以访问 ，在类外部没法访问
3. private ：私有，在当前类里面可以访问，子类、类外部都没法访问

类的静态属性和静态方法

这个比较简单，在类中被static的属性或者方法被称为静态属性和静态方法，他可以直接用类名.属性/方法名调用，不需要实例化类

class Per{
    public name:string;
    public age:number=20;
    //静态属性
    static sex="男";
    constructor(name:string) {
            this.name=name;
    }
    run(){  /*实例方法*/
        alert(`${this.name}在运动`)
    }
    work(){
        alert(`${this.name}在工作`)
    }
    static print(){  /*静态方法  里面没法直接调用类里面的属性*/
        alert('print方法'+Per.sex);
    }
}
// var p=new Per('张三');
// p.run();
Per.print();
alert(Per.sex);

类的多态

父类定义一个方法不去实现，让继承它的子类去实现 每一个子类有不同的表现

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+'吃老鼠'
    }
}

抽象类

它是提供其他类继承的基类，不能直接被实例化。有时候团队开发，需要统一规范，需要开发哪些功能。先由技术经理定义以后抽象类，然后程序员去继承，然后实现。这样做可以做到代码更加规范化

抽象类是不能被示例化的，只能之类去继承，然后实现其所有方法

//标准基类
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(){
        console.log(this.name+'吃粮食')
    }
}
var d=new Dog('小花花');
d.eat();

class Cat extends Animal{
    //抽象类的子类必须实现抽象类里面的抽象方法
    constructor(name:any){
        super(name)
    }
    run(){
    }
    eat(){
        console.log(this.name+'吃老鼠')
    }
}
var c=new Cat('小花猫');
c.eat();

感觉在写java代码…