TypeScript面向对象编程

#1.类的声明和使用

class XiaoJieJie{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name = name
        this.age = age 
    }
    say(){
        console.log('你好')
    }
}
let jiejie:XiaoJieJie = new XiaoJieJie('冰冰',18)
console.log(jiejie)//XiaoJieJie { name: '冰冰', age: 18 }
jiejie.say()//小哥哥好

#2.修饰符
####（1）访问修饰符
访问修饰符分为：public、protected、private。

public:公有修饰符，可以在类内或者类外使用public修饰的属性或者行为，默认修饰符。
protected:受保护的修饰符，可以本类和子类中使用protected修饰的属性和行为（即：protected修饰符与 private修饰符的行为很相似，但有一点不同，protected成员在派生类中仍然可以访问）。
private : 私有修饰符，只可以在类内使用private修饰的属性和行为，不可以在该类的外部访问。

class XiaoJieJie2{
    public sex:string
    protected name:string
    private age:number
    public constructor(sex:string,name:string,age:number){
        this.sex=sex
        this.name=name
        this.age=age
    }
    public sayHello(){
        console.log('你好')
    }

    protected sayHello2(){
        console.log('你好2')
    }
}

var jiejie2:XiaoJieJie2 = new XiaoJieJie2('女','热巴',19)

console.log(jiejie2.sex)
console.log(jiejie2.name)   //报错
console.log(jiejie2.age)    //报错
jiejie2.sayHello()
jiejie2.sayHello2()    //报错

####（2）只读属性修饰符

使用readonly修饰符将属性设置为只读，只读属性必须在生命时或者构造函数里被初始化

class Man{
    public readonly sex:string = '男'
}

var man:Man = new Man()
man.sex='女'
//报错

#3.继承和重写
####（1）类的继承

继承：允许我们创建一个类（子类），从已有的类（父类）上继承所有的属性和方法，子类可以新建父类中没有的属性和方法。

class D{
    public name:string
    public age : number
    public skill: string
    constructor(name:string,age:number,skill:string){
        this.name = name
        this.age = age
        this.skill = skill
    }
    public interest(){
        console.log('学习')
    }
}

let DObj:D = new D('DObj',18,'吃饭')
DObj.interest()//学习
console.log(DObj);//D { name: 'DObj', age: 18, skill: '吃饭' }

class D2 extends D{
    public xingxiang:string = '帅气'
    public zhuanQian(){
        console.log('一天赚了一个亿')
    }
}

let D3= new D2("D3号",5,'演讲')
D3.interest()//学习
D3.zhuanQian()//一天赚了一个亿
console.log(D3);//D2 { name: 'D3号', age: 5, skill: '演讲', xingxiang: '帅气' }

extends关键字就是继承的重点,TypeScript不支持多重继承。

####(2)类方法的重写

重写就是在子类中重写父类的方法。

class D3 extends D2{
    public xingxiang:string = '帅气'
    public interest(){
        super.interest()
        console.log('建立电商平台')
    }
    public zhuanQian(){
        console.log('一天赚了3个亿')
    }
}
let D4= new D3("D4号",5,'asdf ')
D4.zhuanQian()//一天赚了3个亿
D4.interest()//建立电商平台
console.log(D4);//D3 { name: 'D4号', age: 5, skill: 'asdf ', xingxiang: '帅气' }

先是继承了父类的方法，然后通过super关键字调用了父类的方法，实现了技能的增加。
#4.接口
定义接口的关键字是interface

interface FullName{
    firstName:string;   //注意;结束
    secondName:string;
}
let printName:FullName ={ firstName:'zhangsan',secondName:'zhangzhang'}
console.log(printName)

####(1)可选参数接口

interface FullName{
    firstName:string;
    secondName?:string; // 属性可选(可传可不传)
}
function getName(name:FullName){
    console.log(name)
}  
getName({               
    firstName:'firstName'
})

####(2)函数类型接口

对方法传入的参数 以及返回值进行约束

// 加密的函数类型接口
interface encrypt{
    (key:string,value:string):string;
}
var md5:encrypt=function(key:string,value:string):string{
    //模拟操作
    return key+value;
}
console.log(md5('name','zhangsan'));

接口分类参考链接：
http://www.manongjc.com/article/24143.html

#5.命名空间

namespace shuaiGe{
    export class Dehua{
        public name:string = '刘德华'
        talk(){
            console.log('我是帅哥刘德华')
        }
    }
}

namespace bajie{
    export class Dehua{
        public name:string = '马德华'
        talk(){
            console.log('我是二师兄马德华')
        }
    }
}

let dehua1:shuaiGe.Dehua   = new shuaiGe.Dehua()
let dehua2:shuaiGe.Dehua   = new bajie.Dehua()
dehua1.talk()//我是帅哥刘德华
dehua2.talk()//我是二师兄马德华