转载

TypeScript中的类,抽象类以及抽象方法

1.类

 类是模板。
 访问修饰符 ------3种, TS(封装)----------public ,protected,private


class User {

    // 类变量属于类,只有一份,只能通过类名访问
   static info:string="about user"

    // 静态方法-----类方法
    public static about():string{
        // 静态方法中this指 User 这个类
        return this.info;
    }
    // 成员变量
    // public  name:string;
    // private age:number;  //私有属性只能在类里访问
    // protected phone:string; //受保护的只能在类及其子类中访问

    public email :string;

    // 构造方法可以加访问修饰符
    // 构造方法的参数变量也可以加访问修饰符(显示的去声明成员变量)
   public constructor(  
        public  name:string,
        private age?:number, //私有属性只能在类里访问
        protected phone?:string ) {
        // 参数变量赋给成员变量
        this.name=name;
        this.age=age;
        this.phone=phone;
        
    }

    // 方法
    sayHello(msg:string):string{
        // 方法中声明的局部变量
        let text=`${this.name} say:${msg}`
        // 常量-----存在,在类中不支持,方法中可以
        const a=6;
        // a=9;
        return text;
    }
}

let u1:User;
// 方法的重载-------多态
u1=new User("bob");
u1=new User("bob",21);
u1=new User("bob",21,"151558584866");


u1.name="alice";

console.log(u1.sayHello("TS"));

console.log(User.info);

console.log(User.about());

 


2. 抽象类

定义抽象类的意义:被子类继承,是半成品,用于卸生出子类, 把子类中公共的部分提取出来,封装在顶部,易于维护或扩展。

                                   被子类继承,部分抽象,部分实现。

abstract class A {

    // 子类可见
   protected x:number;
    // 只有类内部可见
    private y:number;
    constructor(x?:number,y?:number) {
        this.x=x;
        this.y=y;
    }
    public toString():void{
        console.log(`A x=${this.x},y=${this.y}`);
     }
}

3.抽象方法

abstract class A {

    // 子类可见
   protected x:number;
    // 只有类内部可见
    protected y:number;
    constructor(x?:number,y?:number) {
        this.x=x;
        this.y=y;
    }
    public toString():void{
        console.log(`A x=${this.x},y=${this.y}`);
     }

    //  抽象方法
     abstract foo(n:number):number;
}

4.继承 

A类:

// 继承
abstract class A {

    // 子类可见
   protected x:number;
    // 只有类内部可见
    protected y:number;
    constructor(x?:number,y?:number) {
        this.x=x;
        this.y=y;
    }
    public toString():void{
        console.log(`A x=${this.x},y=${this.y}`);
     }

    //  抽象方法
     abstract foo(n:number):number;
}

B类

class B extends A{

    foo(n: number): number {
        return n+1;
    }

    z:number;

    // 子类的构造器显示调用父类构造方法
    constructor(x:number,y:number,z:number) {
        super(x,y);
        this.z=z;
    }

    // 子类同名方法会覆盖父类中方法
   public toString():void{
        console.log(`B x=${this.x},y=${this.y},z=${this.z}`);
        
        
    }
}

测试代码:

let n2=new B(3,4,5);

// console.log(n.x);
// console.log(n.y);
// console.log(n.z);
// n1.toString();


n2.toString();

 输出结果为:


 扩展

抽象类一定有抽象方法? 
不一定
只能继承,不能直接实例化 

 

正文到此结束
本文目录