TypeScript--類

RobinQu 發(fā)布于2019-08-23 15:12 / 635人閱讀

摘要：中定義類屬性前面省略了關(guān)鍵詞構(gòu)造函數(shù)實(shí)例化類的時(shí)候觸發(fā)的方法繼承在運(yùn)動(dòng)在運(yùn)動(dòng)子類在工作修飾符公有在當(dāng)前類里面子類類外面都可以訪問保護(hù)類型在當(dāng)前類里面子類里面可以訪問，在類外部沒法訪問私有在當(dāng)前類里面可以訪問，子類類外部都沒法訪問在運(yùn)動(dòng)在

ts中定義類

class Person{
    name:string;  //屬性  前面省略了public關(guān)鍵詞
    constructor(n:string){  //構(gòu)造函數(shù)   實(shí)例化類的時(shí)候觸發(fā)的方法
        this.name = n;
    }
    run():void{
        alert(this.name);
    }
}
var p = new Person("lisi");
p.run()

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("lisi");
alert(p.getName());
p.setName("wanwu");
alert(p.getName());

繼承

class Person{
    name:string;
    constructor(name:string){
        this.name = name;
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)`;
    }
}
var p = new Person("lisi");
alert(p.run());

class Web extends Person{
    constructor(name:string){
        super(name);
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)--子類`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}

var w = new Web("wanwu");
alert(w.run());
w.work();

修飾符

public :公有在當(dāng)前類里面、子類、類外面都可以訪問

protected：保護(hù)類型在當(dāng)前類里面、子類里面可以訪問，在類外部沒法訪問

private ：私有在當(dāng)前類里面可以訪問，子類、類外部都沒法訪問

public

class Person{
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)`;
    }
}
var p = new Person("lisi");
alert(p.run());

class Web extends Person{
    constructor(name:string){
        super(name);
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)--子類`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}
var w = new Web("wanwu");
alert(w.run());

protected

class Person{
    protected name:string;
    constructor(name:string){
        this.name = name;
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)`;
    }
}
var p = new Person("lisi");
alert(p.run());

class Web extends Person{
    constructor(name:string){
        super(name);
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)--子類`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}
var w = new Web("wanwu");
alert(w.run());

靜態(tài)屬性靜態(tài)方法

class Person{
    public name:string;  /*公有屬性*/
    static sex = "男" //靜態(tài)屬性
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在運(yùn)動(dòng)`
    }

    static print(){
        // alert("print方法"+this.name);
        alert("print方法"+Person.sex);
    }
}

var p = new Person("lisi");
Person.print();

多態(tài)

多態(tài):父類定義一個(gè)方法不去實(shí)現(xiàn)，讓繼承它的子類去實(shí)現(xiàn)，每一個(gè)子類有不同的表現(xiàn)
多態(tài)屬性繼承

父類有方法，子類也有同樣的方法

class Animal{
    name:string;
    constructor(name:string){
        this.name = name;
    }
    //具體吃什么，不知道，具體吃什么，讓繼承它的子類去實(shí)現(xiàn)，每一個(gè)子類的表現(xiàn)不一樣
    eat(){
        console.log("吃的方法")
    }
}

class Dog extends Animal{
    constructor(name:string){
        super(name);
    }
    eat(){
        return this.name +"吃骨頭"
    }
}
var d = new Dog("d");
alert(d.eat());

class Cat extends Animal{
    constructor(name:string){
        super(name);
    }
    eat(){
        return this.name +"吃魚"
    }
}
var c = new Cat("c");
alert(c.eat());

父類有方法，子類沒有同樣的方法

class Animal{
    name:string;
    constructor(name:string){
        this.name = name;
    }
    //具體吃什么，不知道，具體吃什么，讓繼承它的子類去實(shí)現(xiàn)，每一個(gè)子類的表現(xiàn)不一樣
    eat(){
        console.log("吃的方法")
    }
}

class Dog extends Animal{
    constructor(name:string){
        super(name);
    }
    eat(){
        return this.name +"吃骨頭"
    }
}
var d = new Dog("d");
alert(d.eat());

class Cat extends Animal{
    constructor(name:string){
        super(name);
    }
    // eat(){
    //     return this.name +"吃魚"
    // }
}
var c = new Cat("c");
alert(c.eat());

抽象類

抽象類:它是提供其它繼承的基類，不能直接被實(shí)例化

abstract關(guān)鍵字定義抽象方法，抽象類中的抽象方法不包含具體實(shí)現(xiàn)并且必須在派生類中實(shí)現(xiàn)

abstract抽象方法只能放在抽象類里面

抽象類和抽象方法用來定義標(biāo)準(zhǔn)，標(biāo)準(zhǔn):Animal這個(gè)類要求它的子類必須包含相同的方法，如eat()

直接被實(shí)例化,報(bào)錯(cuò)

abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    abstract eat():any;
    run(){
        console.log("運(yùn)動(dòng)")
    }
}

var a = new Animal();

父類定義的抽象方法，子類沒有定義，報(bào)錯(cuò)

abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    abstract eat():any;
    run(){
        console.log("運(yùn)動(dòng)")
    }
}

class Dog extends Animal{
    constructor(name:string){
        super(name);
    }
    // eat(){
    //     console.log(this.name+"吃骨頭")
    // }

}

正常

類非抽象方法，子類可以不寫

abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name = name;
    }
    abstract eat():any;
    run(){
        console.log("運(yùn)動(dòng)")
    }
}


class Dog extends Animal{
    constructor(name:string){
        super(name);
    }
    eat(){
        console.log(this.name+"吃骨頭")
    }

}

var d = new Dog("d");
d.eat()

class Cat extends Animal{
    constructor(name:string){
        super(name);
    }
    eat(){
        console.log(this.name+"吃魚")
    }
}

var c = new Cat("c");
c.eat()