ts 类笔记

类class相关tsconfig.json

strictNullChecks:false//

设置false，这样类的成员变量默认值可以是null/undefined,你就不一定要给他赋值

基础

class Students{
    readonly f:string="hello word";
    a:number=10;
    static b:number=1; 
    c(str:string):number{
         return parseFloat(str);
    }
    private d:string="hello world";
    public e:string="yes";
 }
 //静态变量可以直接调用
 console.log(Students.b);
 //其他，只能通过对象实例化后，才能操作
 var obj= new Students();
 console.log(obj.a);
 console.log(obj.c("222.2"));
 console.log(typeof(obj.c("222.2")));
 // console.log(obj.d);//private 不能被实例调用
 console.log(obj.e);//感觉是和c++的类成员不一样，ts的class成员默认是public,c++默认是private
 console.log(obj.f)//只读不能改

 构造函数

class BOX{
    a:number=2;
    constructor(num:number=2){
        this.a=num;
    }
    log():void{
        console.log(this.a);
    }
}
var box=new BOX(3);
box.log();

 

 继承

class BOX{
    private a:number=2;
    constructor(num:number=2){
        this.a=num;
    }
    protected log():void{
        console.log(this.a);
    }
}
class CYC extends BOX {
    get(){
        // this.a//会报错private 不可继承
        this.log();//protected可以继承。
    }
}
var cyc=new CYC(3);
cyc.get();
// console.log(CYC.a)//private 外面不能直接调用

private 和protected  都是不能用cyc.log和cyc.a来调用的！

但是protected 可以被 继承，但是private不行。

class cyc{
    x:string;
    constructor(name:string){
        this.x=name;
    }
    getVal(){
        console.log(this.x);
    }
}
class box extends cyc{
    constructor(name:string){
        super(name);//派生类如果有constructor，那这个构造函数第一句就要是super();意思是调用基类的构造函数
    }
}
var dd =new box("你好");
dd.getVal();

重写类成员变量或函数

class BOX{
    private a:number=2;
    constructor(num:number=2){
        this.a=num;
    }
    protected log():void{
        console.log(this.a);
    }
}
class CYC extends BOX {
    log():void{
        //this.log();//重写函数的时候，就不能用this.log
        super.log();//protected
    }
}
var cyc=new CYC(3);
cyc.log();

 instanceof 判断是不是制定类型

class BOX{
    private a:number=2;
    constructor(num:number=2){
        this.a=num;
    }
    protected log():void{
        console.log(this.a);
    }
}
class CYC extends BOX {
    log():void{
        //this.log();//重写函数的时候，就不能用this.log
        super.log();//protected
    }
}
class CYC1{}

var cyc=new CYC(3);
var isTrue:boolean=cyc instanceof CYC1;
console.log(isTrue)
var isTrue2:boolean=cyc instanceof CYC;
console.log(isTrue2)

接口最为类的属性

interface BOX{
    size?:number;
    len?:number
}
class CYC implements BOX{
    size:number;
    constructor(size:number=1){
        this.size=size;
    }
    getSize():void{
        console.log(this.size)
    }
}
var cyc=new CYC();
cyc.getSize();

类存取器

class Login{
    private userName:string="小白";
    private propkey:string
    constructor(propkey:string){
        this.propkey=propkey;
    }
    get name(){
        return this.userName;
    }
    set name(newName){
        if(this.propkey=="4055"){
            this.userName=newName;
        }else{
            console.log("秘钥错误，你暂无权修改用户名");
        }
    }
}
var a=new Login("4055");
a.name="wx搜：程序员野区";
console.log(a.name);
var b=new Login("4555");
console.log("----",b.name);
b.name="wx搜：程序员实用资源";
console.log(b.name);

抽象类

抽象类，博主理解是为了规范同一场景的操作，比如增、删、改各新增一个抽象类，abstract userInfo():void;//表示 抽象类里不实现，但是派生类要实现，那你新增的时候提交动作是不是一定要有，提交前的表单验证动作是不是要有，这时候就得用到抽象方法abstract +方法命来约束派生类里必须有userInfo这个方法的实现对提交这个动作进行处理和验证。

abstract class login{
    constructor(public name:string){

    }
    userName():void{
        console.log(this.name);
    }
    abstract userInfo():void;//
}
class info extends login{
    constructor(public n:string,public password:string){
        super(n);
    }
    userInfo(){
        console.log("用户名:",this.n,",密码：",this.password);
    }
}
var t=new info("cyc","123456")
t.userInfo();
//当然，也可以写成
var z:login=new info("ycy","123566") ;
z.userInfo();

 类当接口来用

class cyc{
    x:number|undefined;
    y:number|undefined;
}
interface box extends cyc{
    z:number
}
let zyz:box={x:1,y:1,z:1}
console.log(zyz);